﻿
//*****************************************************************************************************\\
// Copyright (©) Sergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
// This code is distributed under the Unlicense
// For details see LICENSE file or this:
// https://github.com/SunSerega/POCGL/blob/master/LICENSE
//*****************************************************************************************************\\
// Copyright (©) Сергей Латченко ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
// Данный код распространяется с лицензией Unlicense
// Подробнее в файле LICENSE или тут:
// https://github.com/SunSerega/POCGL/blob/master/LICENSE
//*****************************************************************************************************\\

///
///Код переведён отсюда:
///   https://github.com/KhronosGroup/OpenCL-Docs/tree/master/xml
///
///Спецификации всех версий OpenCL:
///   https://www.khronos.org/registry/OpenCL/
///
///Если чего-либо не хватает, или найдена ошибка - писать сюда:
///   https://github.com/SunSerega/POCGL/issues
///
unit OpenCL;

interface

uses System;
uses System.Runtime.InteropServices;
uses System.Runtime.CompilerServices;

type
  
  {$region Записи-имена}
  
  cl_mem = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_mem read default(cl_mem);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_mem[{val}]';
  end;
  cl_platform_id = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_platform_id read default(cl_platform_id);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_platform_id[{val}]';
  end;
  cl_device_id = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_device_id read default(cl_device_id);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_device_id[{val}]';
  end;
  cl_context = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_context read default(cl_context);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_context[{val}]';
  end;
  cl_command_queue = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_command_queue read default(cl_command_queue);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_command_queue[{val}]';
  end;
  cl_sampler = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_sampler read default(cl_sampler);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_sampler[{val}]';
  end;
  cl_program = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_program read default(cl_program);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_program[{val}]';
  end;
  cl_kernel = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_kernel read default(cl_kernel);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_kernel[{val}]';
  end;
  cl_event = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_event read default(cl_event);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_event[{val}]';
  end;
  cl_accelerator_intel = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_accelerator_intel read default(cl_accelerator_intel);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_accelerator_intel[{val}]';
  end;
  
  cl_semaphore = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_semaphore read default(cl_semaphore);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_semaphore[{val}]';
  end;
  cl_command_buffer = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_command_buffer read default(cl_command_buffer);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_command_buffer[{val}]';
  end;
  cl_mutable_command = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public static property Zero: cl_mutable_command read default(cl_mutable_command);
    public static property Size: integer read Marshal.SizeOf&<IntPtr>;
    public function ToString: string; override := $'cl_mutable_command[{val}]';
  end;
  
  {$endregion Записи-имена}
  
  {$region Перечисления}
  
  {$region Core}
  
  AcceleratorInfoIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property ACCELERATOR_DESCRIPTOR_INTEL:      AcceleratorInfoIntel read new AcceleratorInfoIntel($4090);
    public static property ACCELERATOR_REFERENCE_COUNT_INTEL: AcceleratorInfoIntel read new AcceleratorInfoIntel($4091);
    public static property ACCELERATOR_CONTEXT_INTEL:         AcceleratorInfoIntel read new AcceleratorInfoIntel($4092);
    public static property ACCELERATOR_TYPE_INTEL:            AcceleratorInfoIntel read new AcceleratorInfoIntel($4093);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4090) then Result := 'ACCELERATOR_DESCRIPTOR_INTEL' else
      if self.val = UInt32($4091) then Result := 'ACCELERATOR_REFERENCE_COUNT_INTEL' else
      if self.val = UInt32($4092) then Result := 'ACCELERATOR_CONTEXT_INTEL' else
      if self.val = UInt32($4093) then Result := 'ACCELERATOR_TYPE_INTEL' else
        Result := $'AcceleratorInfoIntel[{self.val}]';
    end;
    
  end;
  
  AcceleratorTypeIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL: AcceleratorTypeIntel read new AcceleratorTypeIntel($0000);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL' else
        Result := $'AcceleratorTypeIntel[{self.val}]';
    end;
    
  end;
  
  AddressingMode = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property ADDRESS_NONE:            AddressingMode read new AddressingMode($1130);
    public static property ADDRESS_CLAMP_TO_EDGE:   AddressingMode read new AddressingMode($1131);
    public static property ADDRESS_CLAMP:           AddressingMode read new AddressingMode($1132);
    public static property ADDRESS_REPEAT:          AddressingMode read new AddressingMode($1133);
    public static property ADDRESS_MIRRORED_REPEAT: AddressingMode read new AddressingMode($1134);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1130) then Result := 'ADDRESS_NONE' else
      if self.val = UInt32($1131) then Result := 'ADDRESS_CLAMP_TO_EDGE' else
      if self.val = UInt32($1132) then Result := 'ADDRESS_CLAMP' else
      if self.val = UInt32($1133) then Result := 'ADDRESS_REPEAT' else
      if self.val = UInt32($1134) then Result := 'ADDRESS_MIRRORED_REPEAT' else
        Result := $'AddressingMode[{self.val}]';
    end;
    
  end;
  
  Bool = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property FALSE:        Bool read new Bool($0000);
    public static property NON_BLOCKING: Bool read new Bool($0000);
    public static property BLOCKING:     Bool read new Bool($0001);
    public static property TRUE:         Bool read new Bool($0001);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'FALSE' else
      if self.val = UInt32($0000) then Result := 'NON_BLOCKING' else
      if self.val = UInt32($0001) then Result := 'BLOCKING' else
      if self.val = UInt32($0001) then Result := 'TRUE' else
        Result := $'Bool[{self.val}]';
    end;
    
    public static function operator implicit(b: Bool): boolean := b.val<>Bool.FALSE.val;
    public static function operator implicit(b: boolean): Bool := new Bool(UInt32(b));
    
    public static function operator not(b: Bool): Bool := b.val=Bool.FALSE.val ? Bool.TRUE : Bool.FALSE;
    
  end;
  
  BufferCreateType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property BUFFER_CREATE_TYPE_REGION: BufferCreateType read new BufferCreateType($1220);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1220) then Result := 'BUFFER_CREATE_TYPE_REGION' else
        Result := $'BufferCreateType[{self.val}]';
    end;
    
  end;
  
  BuildStatus = record
    public val: Int32;
    public constructor(val: Int32) := self.val := val;
    
    public static property BUILD_SUCCESS:     BuildStatus read new BuildStatus($0000);
    public static property BUILD_NONE:        BuildStatus read new BuildStatus(-1);
    public static property BUILD_ERROR:       BuildStatus read new BuildStatus(-2);
    public static property BUILD_IN_PROGRESS: BuildStatus read new BuildStatus(-3);
    
    public function ToString: string; override;
    begin
      if self.val = Int32($0000) then Result := 'BUILD_SUCCESS' else
      if self.val = Int32(-1) then Result := 'BUILD_NONE' else
      if self.val = Int32(-2) then Result := 'BUILD_ERROR' else
      if self.val = Int32(-3) then Result := 'BUILD_IN_PROGRESS' else
        Result := $'BuildStatus[{self.val}]';
    end;
    
  end;
  
  ChannelOrder = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property R:             ChannelOrder read new ChannelOrder($10B0);
    public static property A:             ChannelOrder read new ChannelOrder($10B1);
    public static property RG:            ChannelOrder read new ChannelOrder($10B2);
    public static property RA:            ChannelOrder read new ChannelOrder($10B3);
    public static property RGB:           ChannelOrder read new ChannelOrder($10B4);
    public static property RGBA:          ChannelOrder read new ChannelOrder($10B5);
    public static property BGRA:          ChannelOrder read new ChannelOrder($10B6);
    public static property ARGB:          ChannelOrder read new ChannelOrder($10B7);
    public static property INTENSITY:     ChannelOrder read new ChannelOrder($10B8);
    public static property LUMINANCE:     ChannelOrder read new ChannelOrder($10B9);
    public static property Rx:            ChannelOrder read new ChannelOrder($10BA);
    public static property RGx:           ChannelOrder read new ChannelOrder($10BB);
    public static property RGBx:          ChannelOrder read new ChannelOrder($10BC);
    public static property DEPTH:         ChannelOrder read new ChannelOrder($10BD);
    public static property DEPTH_STENCIL: ChannelOrder read new ChannelOrder($10BE);
    public static property sRGB:          ChannelOrder read new ChannelOrder($10BF);
    public static property sRGBx:         ChannelOrder read new ChannelOrder($10C0);
    public static property sRGBA:         ChannelOrder read new ChannelOrder($10C1);
    public static property sBGRA:         ChannelOrder read new ChannelOrder($10C2);
    public static property ABGR:          ChannelOrder read new ChannelOrder($10C3);
    public static property YUYV_INTEL:    ChannelOrder read new ChannelOrder($4076);
    public static property UYVY_INTEL:    ChannelOrder read new ChannelOrder($4077);
    public static property YVYU_INTEL:    ChannelOrder read new ChannelOrder($4078);
    public static property VYUY_INTEL:    ChannelOrder read new ChannelOrder($4079);
    public static property NV21_IMG:      ChannelOrder read new ChannelOrder($40D0);
    public static property YV12_IMG:      ChannelOrder read new ChannelOrder($40D1);
    public static property NV12_INTEL:    ChannelOrder read new ChannelOrder($410E);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($10B0) then Result := 'R' else
      if self.val = UInt32($10B1) then Result := 'A' else
      if self.val = UInt32($10B2) then Result := 'RG' else
      if self.val = UInt32($10B3) then Result := 'RA' else
      if self.val = UInt32($10B4) then Result := 'RGB' else
      if self.val = UInt32($10B5) then Result := 'RGBA' else
      if self.val = UInt32($10B6) then Result := 'BGRA' else
      if self.val = UInt32($10B7) then Result := 'ARGB' else
      if self.val = UInt32($10B8) then Result := 'INTENSITY' else
      if self.val = UInt32($10B9) then Result := 'LUMINANCE' else
      if self.val = UInt32($10BA) then Result := 'Rx' else
      if self.val = UInt32($10BB) then Result := 'RGx' else
      if self.val = UInt32($10BC) then Result := 'RGBx' else
      if self.val = UInt32($10BD) then Result := 'DEPTH' else
      if self.val = UInt32($10BE) then Result := 'DEPTH_STENCIL' else
      if self.val = UInt32($10BF) then Result := 'sRGB' else
      if self.val = UInt32($10C0) then Result := 'sRGBx' else
      if self.val = UInt32($10C1) then Result := 'sRGBA' else
      if self.val = UInt32($10C2) then Result := 'sBGRA' else
      if self.val = UInt32($10C3) then Result := 'ABGR' else
      if self.val = UInt32($4076) then Result := 'YUYV_INTEL' else
      if self.val = UInt32($4077) then Result := 'UYVY_INTEL' else
      if self.val = UInt32($4078) then Result := 'YVYU_INTEL' else
      if self.val = UInt32($4079) then Result := 'VYUY_INTEL' else
      if self.val = UInt32($40D0) then Result := 'NV21_IMG' else
      if self.val = UInt32($40D1) then Result := 'YV12_IMG' else
      if self.val = UInt32($410E) then Result := 'NV12_INTEL' else
        Result := $'ChannelOrder[{self.val}]';
    end;
    
  end;
  
  ChannelType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property SNORM_INT8:         ChannelType read new ChannelType($10D0);
    public static property SNORM_INT16:        ChannelType read new ChannelType($10D1);
    public static property UNORM_INT8:         ChannelType read new ChannelType($10D2);
    public static property UNORM_INT16:        ChannelType read new ChannelType($10D3);
    public static property UNORM_SHORT_565:    ChannelType read new ChannelType($10D4);
    public static property UNORM_SHORT_555:    ChannelType read new ChannelType($10D5);
    public static property UNORM_INT_101010:   ChannelType read new ChannelType($10D6);
    public static property SIGNED_INT8:        ChannelType read new ChannelType($10D7);
    public static property SIGNED_INT16:       ChannelType read new ChannelType($10D8);
    public static property SIGNED_INT32:       ChannelType read new ChannelType($10D9);
    public static property UNSIGNED_INT8:      ChannelType read new ChannelType($10DA);
    public static property UNSIGNED_INT16:     ChannelType read new ChannelType($10DB);
    public static property UNSIGNED_INT32:     ChannelType read new ChannelType($10DC);
    public static property HALF_FLOAT:         ChannelType read new ChannelType($10DD);
    public static property FLOAT:              ChannelType read new ChannelType($10DE);
    public static property UNORM_INT24:        ChannelType read new ChannelType($10DF);
    public static property UNORM_INT_101010_2: ChannelType read new ChannelType($10E0);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($10D0) then Result := 'SNORM_INT8' else
      if self.val = UInt32($10D1) then Result := 'SNORM_INT16' else
      if self.val = UInt32($10D2) then Result := 'UNORM_INT8' else
      if self.val = UInt32($10D3) then Result := 'UNORM_INT16' else
      if self.val = UInt32($10D4) then Result := 'UNORM_SHORT_565' else
      if self.val = UInt32($10D5) then Result := 'UNORM_SHORT_555' else
      if self.val = UInt32($10D6) then Result := 'UNORM_INT_101010' else
      if self.val = UInt32($10D7) then Result := 'SIGNED_INT8' else
      if self.val = UInt32($10D8) then Result := 'SIGNED_INT16' else
      if self.val = UInt32($10D9) then Result := 'SIGNED_INT32' else
      if self.val = UInt32($10DA) then Result := 'UNSIGNED_INT8' else
      if self.val = UInt32($10DB) then Result := 'UNSIGNED_INT16' else
      if self.val = UInt32($10DC) then Result := 'UNSIGNED_INT32' else
      if self.val = UInt32($10DD) then Result := 'HALF_FLOAT' else
      if self.val = UInt32($10DE) then Result := 'FLOAT' else
      if self.val = UInt32($10DF) then Result := 'UNORM_INT24' else
      if self.val = UInt32($10E0) then Result := 'UNORM_INT_101010_2' else
        Result := $'ChannelType[{self.val}]';
    end;
    
  end;
  
  CommandBufferInfoKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property COMMAND_BUFFER_QUEUES_KHR:           CommandBufferInfoKhr read new CommandBufferInfoKhr($1294);
    public static property COMMAND_BUFFER_NUM_QUEUES_KHR:       CommandBufferInfoKhr read new CommandBufferInfoKhr($1295);
    public static property COMMAND_BUFFER_REFERENCE_COUNT_KHR:  CommandBufferInfoKhr read new CommandBufferInfoKhr($1296);
    public static property COMMAND_BUFFER_STATE_KHR:            CommandBufferInfoKhr read new CommandBufferInfoKhr($1297);
    public static property COMMAND_BUFFER_PROPERTIES_ARRAY_KHR: CommandBufferInfoKhr read new CommandBufferInfoKhr($1298);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1294) then Result := 'COMMAND_BUFFER_QUEUES_KHR' else
      if self.val = UInt32($1295) then Result := 'COMMAND_BUFFER_NUM_QUEUES_KHR' else
      if self.val = UInt32($1296) then Result := 'COMMAND_BUFFER_REFERENCE_COUNT_KHR' else
      if self.val = UInt32($1297) then Result := 'COMMAND_BUFFER_STATE_KHR' else
      if self.val = UInt32($1298) then Result := 'COMMAND_BUFFER_PROPERTIES_ARRAY_KHR' else
        Result := $'CommandBufferInfoKhr[{self.val}]';
    end;
    
  end;
  
  CommandBufferPropertiesKhr = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property COMMAND_BUFFER_FLAGS_KHR: CommandBufferPropertiesKhr read new CommandBufferPropertiesKhr($1293);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($1293) then Result := 'COMMAND_BUFFER_FLAGS_KHR' else
        Result := $'CommandBufferPropertiesKhr[{self.val}]';
    end;
    
  end;
  
  CommandExecutionStatus = record
    public val: Int32;
    public constructor(val: Int32) := self.val := val;
    
    public static property COMPLETE:  CommandExecutionStatus read new CommandExecutionStatus($0000);
    public static property RUNNING:   CommandExecutionStatus read new CommandExecutionStatus($0001);
    public static property SUBMITTED: CommandExecutionStatus read new CommandExecutionStatus($0002);
    public static property QUEUED:    CommandExecutionStatus read new CommandExecutionStatus($0003);
    
    public function ToString: string; override;
    begin
      if self.val = Int32($0000) then Result := 'COMPLETE' else
      if self.val = Int32($0001) then Result := 'RUNNING' else
      if self.val = Int32($0002) then Result := 'SUBMITTED' else
      if self.val = Int32($0003) then Result := 'QUEUED' else
        Result := $'CommandExecutionStatus[{self.val}]';
    end;
    
    public function IS_ERROR := val < 0;
    
  end;
  
  CommandQueueInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property QUEUE_CONTEXT:          CommandQueueInfo read new CommandQueueInfo($1090);
    public static property QUEUE_DEVICE:           CommandQueueInfo read new CommandQueueInfo($1091);
    public static property QUEUE_REFERENCE_COUNT:  CommandQueueInfo read new CommandQueueInfo($1092);
    public static property QUEUE_PROPERTIES:       CommandQueueInfo read new CommandQueueInfo($1093);
    public static property QUEUE_SIZE:             CommandQueueInfo read new CommandQueueInfo($1094);
    public static property QUEUE_DEVICE_DEFAULT:   CommandQueueInfo read new CommandQueueInfo($1095);
    public static property QUEUE_PROPERTIES_ARRAY: CommandQueueInfo read new CommandQueueInfo($1098);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1090) then Result := 'QUEUE_CONTEXT' else
      if self.val = UInt32($1091) then Result := 'QUEUE_DEVICE' else
      if self.val = UInt32($1092) then Result := 'QUEUE_REFERENCE_COUNT' else
      if self.val = UInt32($1093) then Result := 'QUEUE_PROPERTIES' else
      if self.val = UInt32($1094) then Result := 'QUEUE_SIZE' else
      if self.val = UInt32($1095) then Result := 'QUEUE_DEVICE_DEFAULT' else
      if self.val = UInt32($1098) then Result := 'QUEUE_PROPERTIES_ARRAY' else
        Result := $'CommandQueueInfo[{self.val}]';
    end;
    
  end;
  
  CommandQueueProperties = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property NONE:                                 CommandQueueProperties read new CommandQueueProperties($0000);
    public static property QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE:  CommandQueueProperties read new CommandQueueProperties($0001);
    public static property QUEUE_PROFILING_ENABLE:               CommandQueueProperties read new CommandQueueProperties($0002);
    public static property QUEUE_ON_DEVICE:                      CommandQueueProperties read new CommandQueueProperties($0004);
    public static property QUEUE_ON_DEVICE_DEFAULT:              CommandQueueProperties read new CommandQueueProperties($0008);
    public static property QUEUE_RESERVED_QCOM:                  CommandQueueProperties read new CommandQueueProperties($40000000);
    public static property QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL: CommandQueueProperties read new CommandQueueProperties($80000000);
    
    public static function operator+(f1,f2: CommandQueueProperties) := new CommandQueueProperties(f1.val or f2.val);
    public static function operator or(f1,f2: CommandQueueProperties) := f1+f2;
    
    public property ANY_FLAGS: boolean read self.val<>0;
    public property HAS_FLAG_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE:  boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_QUEUE_PROFILING_ENABLE:               boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_QUEUE_ON_DEVICE:                      boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_QUEUE_ON_DEVICE_DEFAULT:              boolean read self.val and $0008 <> 0;
    public property HAS_FLAG_QUEUE_RESERVED_QCOM:                  boolean read self.val and $40000000 <> 0;
    public property HAS_FLAG_QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL: boolean read self.val and $80000000 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0000) = UInt64($0000) then res += 'NONE+';
      if self.val and UInt64($0001) = UInt64($0001) then res += 'QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'QUEUE_PROFILING_ENABLE+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'QUEUE_ON_DEVICE+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'QUEUE_ON_DEVICE_DEFAULT+';
      if self.val and UInt64($40000000) = UInt64($40000000) then res += 'QUEUE_RESERVED_QCOM+';
      if self.val and UInt64($80000000) = UInt64($80000000) then res += 'QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'CommandQueueProperties[{self.val}]';
    end;
    
  end;
  
  CommandType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property COMMAND_NDRANGE_KERNEL:                      CommandType read new CommandType($11F0);
    public static property COMMAND_TASK:                                CommandType read new CommandType($11F1);
    public static property COMMAND_NATIVE_KERNEL:                       CommandType read new CommandType($11F2);
    public static property COMMAND_READ_BUFFER:                         CommandType read new CommandType($11F3);
    public static property COMMAND_WRITE_BUFFER:                        CommandType read new CommandType($11F4);
    public static property COMMAND_COPY_BUFFER:                         CommandType read new CommandType($11F5);
    public static property COMMAND_READ_IMAGE:                          CommandType read new CommandType($11F6);
    public static property COMMAND_WRITE_IMAGE:                         CommandType read new CommandType($11F7);
    public static property COMMAND_COPY_IMAGE:                          CommandType read new CommandType($11F8);
    public static property COMMAND_COPY_IMAGE_TO_BUFFER:                CommandType read new CommandType($11F9);
    public static property COMMAND_COPY_BUFFER_TO_IMAGE:                CommandType read new CommandType($11FA);
    public static property COMMAND_MAP_BUFFER:                          CommandType read new CommandType($11FB);
    public static property COMMAND_MAP_IMAGE:                           CommandType read new CommandType($11FC);
    public static property COMMAND_UNMAP_MEM_OBJECT:                    CommandType read new CommandType($11FD);
    public static property COMMAND_MARKER:                              CommandType read new CommandType($11FE);
    public static property COMMAND_ACQUIRE_GL_OBJECTS:                  CommandType read new CommandType($11FF);
    public static property COMMAND_RELEASE_GL_OBJECTS:                  CommandType read new CommandType($1200);
    public static property COMMAND_READ_BUFFER_RECT:                    CommandType read new CommandType($1201);
    public static property COMMAND_WRITE_BUFFER_RECT:                   CommandType read new CommandType($1202);
    public static property COMMAND_COPY_BUFFER_RECT:                    CommandType read new CommandType($1203);
    public static property COMMAND_USER:                                CommandType read new CommandType($1204);
    public static property COMMAND_BARRIER:                             CommandType read new CommandType($1205);
    public static property COMMAND_MIGRATE_MEM_OBJECTS:                 CommandType read new CommandType($1206);
    public static property COMMAND_FILL_BUFFER:                         CommandType read new CommandType($1207);
    public static property COMMAND_FILL_IMAGE:                          CommandType read new CommandType($1208);
    public static property COMMAND_SVM_FREE:                            CommandType read new CommandType($1209);
    public static property COMMAND_SVM_MEMCPY:                          CommandType read new CommandType($120A);
    public static property COMMAND_SVM_MEMFILL:                         CommandType read new CommandType($120B);
    public static property COMMAND_SVM_MAP:                             CommandType read new CommandType($120C);
    public static property COMMAND_SVM_UNMAP:                           CommandType read new CommandType($120D);
    public static property COMMAND_SVM_MIGRATE_MEM:                     CommandType read new CommandType($120E);
    public static property COMMAND_COMMAND_BUFFER_KHR:                  CommandType read new CommandType($12A8);
    public static property COMMAND_GL_FENCE_SYNC_OBJECT_KHR:            CommandType read new CommandType($200D);
    public static property COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR:      CommandType read new CommandType($202B);
    public static property COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR:      CommandType read new CommandType($202C);
    public static property COMMAND_SEMAPHORE_WAIT_KHR:                  CommandType read new CommandType($2042);
    public static property COMMAND_SEMAPHORE_SIGNAL_KHR:                CommandType read new CommandType($2043);
    public static property COMMAND_ACQUIRE_EXTERNAL_MEM_OBJECTS_KHR:    CommandType read new CommandType($2047);
    public static property COMMAND_RELEASE_EXTERNAL_MEM_OBJECTS_KHR:    CommandType read new CommandType($2048);
    public static property COMMAND_ACQUIRE_D3D10_OBJECTS_KHR:           CommandType read new CommandType($4017);
    public static property COMMAND_RELEASE_D3D10_OBJECTS_KHR:           CommandType read new CommandType($4018);
    public static property COMMAND_ACQUIRE_D3D11_OBJECTS_KHR:           CommandType read new CommandType($4020);
    public static property COMMAND_RELEASE_D3D11_OBJECTS_KHR:           CommandType read new CommandType($4021);
    public static property COMMAND_ACQUIRE_DX9_OBJECTS_INTEL:           CommandType read new CommandType($402A);
    public static property COMMAND_RELEASE_DX9_OBJECTS_INTEL:           CommandType read new CommandType($402B);
    public static property COMMAND_MIGRATE_MEM_OBJECT_EXT:              CommandType read new CommandType($4040);
    public static property COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL: CommandType read new CommandType($409A);
    public static property COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL: CommandType read new CommandType($409B);
    public static property COMMAND_SVM_FREE_ARM:                        CommandType read new CommandType($40BA);
    public static property COMMAND_SVM_MEMCPY_ARM:                      CommandType read new CommandType($40BB);
    public static property COMMAND_SVM_MEMFILL_ARM:                     CommandType read new CommandType($40BC);
    public static property COMMAND_SVM_MAP_ARM:                         CommandType read new CommandType($40BD);
    public static property COMMAND_SVM_UNMAP_ARM:                       CommandType read new CommandType($40BE);
    public static property COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG:         CommandType read new CommandType($40D2);
    public static property COMMAND_RELEASE_GRALLOC_OBJECTS_IMG:         CommandType read new CommandType($40D3);
    public static property COMMAND_GENERATE_MIPMAP_IMG:                 CommandType read new CommandType($40D6);
    public static property COMMAND_MEMFILL_INTEL:                       CommandType read new CommandType($4204);
    public static property COMMAND_MEMCPY_INTEL:                        CommandType read new CommandType($4205);
    public static property COMMAND_MIGRATEMEM_INTEL:                    CommandType read new CommandType($4206);
    public static property COMMAND_MEMADVISE_INTEL:                     CommandType read new CommandType($4207);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11F0) then Result := 'COMMAND_NDRANGE_KERNEL' else
      if self.val = UInt32($11F1) then Result := 'COMMAND_TASK' else
      if self.val = UInt32($11F2) then Result := 'COMMAND_NATIVE_KERNEL' else
      if self.val = UInt32($11F3) then Result := 'COMMAND_READ_BUFFER' else
      if self.val = UInt32($11F4) then Result := 'COMMAND_WRITE_BUFFER' else
      if self.val = UInt32($11F5) then Result := 'COMMAND_COPY_BUFFER' else
      if self.val = UInt32($11F6) then Result := 'COMMAND_READ_IMAGE' else
      if self.val = UInt32($11F7) then Result := 'COMMAND_WRITE_IMAGE' else
      if self.val = UInt32($11F8) then Result := 'COMMAND_COPY_IMAGE' else
      if self.val = UInt32($11F9) then Result := 'COMMAND_COPY_IMAGE_TO_BUFFER' else
      if self.val = UInt32($11FA) then Result := 'COMMAND_COPY_BUFFER_TO_IMAGE' else
      if self.val = UInt32($11FB) then Result := 'COMMAND_MAP_BUFFER' else
      if self.val = UInt32($11FC) then Result := 'COMMAND_MAP_IMAGE' else
      if self.val = UInt32($11FD) then Result := 'COMMAND_UNMAP_MEM_OBJECT' else
      if self.val = UInt32($11FE) then Result := 'COMMAND_MARKER' else
      if self.val = UInt32($11FF) then Result := 'COMMAND_ACQUIRE_GL_OBJECTS' else
      if self.val = UInt32($1200) then Result := 'COMMAND_RELEASE_GL_OBJECTS' else
      if self.val = UInt32($1201) then Result := 'COMMAND_READ_BUFFER_RECT' else
      if self.val = UInt32($1202) then Result := 'COMMAND_WRITE_BUFFER_RECT' else
      if self.val = UInt32($1203) then Result := 'COMMAND_COPY_BUFFER_RECT' else
      if self.val = UInt32($1204) then Result := 'COMMAND_USER' else
      if self.val = UInt32($1205) then Result := 'COMMAND_BARRIER' else
      if self.val = UInt32($1206) then Result := 'COMMAND_MIGRATE_MEM_OBJECTS' else
      if self.val = UInt32($1207) then Result := 'COMMAND_FILL_BUFFER' else
      if self.val = UInt32($1208) then Result := 'COMMAND_FILL_IMAGE' else
      if self.val = UInt32($1209) then Result := 'COMMAND_SVM_FREE' else
      if self.val = UInt32($120A) then Result := 'COMMAND_SVM_MEMCPY' else
      if self.val = UInt32($120B) then Result := 'COMMAND_SVM_MEMFILL' else
      if self.val = UInt32($120C) then Result := 'COMMAND_SVM_MAP' else
      if self.val = UInt32($120D) then Result := 'COMMAND_SVM_UNMAP' else
      if self.val = UInt32($120E) then Result := 'COMMAND_SVM_MIGRATE_MEM' else
      if self.val = UInt32($12A8) then Result := 'COMMAND_COMMAND_BUFFER_KHR' else
      if self.val = UInt32($200D) then Result := 'COMMAND_GL_FENCE_SYNC_OBJECT_KHR' else
      if self.val = UInt32($202B) then Result := 'COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR' else
      if self.val = UInt32($202C) then Result := 'COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR' else
      if self.val = UInt32($2042) then Result := 'COMMAND_SEMAPHORE_WAIT_KHR' else
      if self.val = UInt32($2043) then Result := 'COMMAND_SEMAPHORE_SIGNAL_KHR' else
      if self.val = UInt32($2047) then Result := 'COMMAND_ACQUIRE_EXTERNAL_MEM_OBJECTS_KHR' else
      if self.val = UInt32($2048) then Result := 'COMMAND_RELEASE_EXTERNAL_MEM_OBJECTS_KHR' else
      if self.val = UInt32($4017) then Result := 'COMMAND_ACQUIRE_D3D10_OBJECTS_KHR' else
      if self.val = UInt32($4018) then Result := 'COMMAND_RELEASE_D3D10_OBJECTS_KHR' else
      if self.val = UInt32($4020) then Result := 'COMMAND_ACQUIRE_D3D11_OBJECTS_KHR' else
      if self.val = UInt32($4021) then Result := 'COMMAND_RELEASE_D3D11_OBJECTS_KHR' else
      if self.val = UInt32($402A) then Result := 'COMMAND_ACQUIRE_DX9_OBJECTS_INTEL' else
      if self.val = UInt32($402B) then Result := 'COMMAND_RELEASE_DX9_OBJECTS_INTEL' else
      if self.val = UInt32($4040) then Result := 'COMMAND_MIGRATE_MEM_OBJECT_EXT' else
      if self.val = UInt32($409A) then Result := 'COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL' else
      if self.val = UInt32($409B) then Result := 'COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL' else
      if self.val = UInt32($40BA) then Result := 'COMMAND_SVM_FREE_ARM' else
      if self.val = UInt32($40BB) then Result := 'COMMAND_SVM_MEMCPY_ARM' else
      if self.val = UInt32($40BC) then Result := 'COMMAND_SVM_MEMFILL_ARM' else
      if self.val = UInt32($40BD) then Result := 'COMMAND_SVM_MAP_ARM' else
      if self.val = UInt32($40BE) then Result := 'COMMAND_SVM_UNMAP_ARM' else
      if self.val = UInt32($40D2) then Result := 'COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG' else
      if self.val = UInt32($40D3) then Result := 'COMMAND_RELEASE_GRALLOC_OBJECTS_IMG' else
      if self.val = UInt32($40D6) then Result := 'COMMAND_GENERATE_MIPMAP_IMG' else
      if self.val = UInt32($4204) then Result := 'COMMAND_MEMFILL_INTEL' else
      if self.val = UInt32($4205) then Result := 'COMMAND_MEMCPY_INTEL' else
      if self.val = UInt32($4206) then Result := 'COMMAND_MIGRATEMEM_INTEL' else
      if self.val = UInt32($4207) then Result := 'COMMAND_MEMADVISE_INTEL' else
        Result := $'CommandType[{self.val}]';
    end;
    
  end;
  
  ContextInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property CONTEXT_REFERENCE_COUNT:                   ContextInfo read new ContextInfo($1080);
    public static property CONTEXT_DEVICES:                           ContextInfo read new ContextInfo($1081);
    public static property CONTEXT_PROPERTIES:                        ContextInfo read new ContextInfo($1082);
    public static property CONTEXT_NUM_DEVICES:                       ContextInfo read new ContextInfo($1083);
    public static property CONTEXT_ADAPTER_D3D9_KHR:                  ContextInfo read new ContextInfo($2025);
    public static property CONTEXT_ADAPTER_D3D9EX_KHR:                ContextInfo read new ContextInfo($2026);
    public static property CONTEXT_ADAPTER_DXVA_KHR:                  ContextInfo read new ContextInfo($2027);
    public static property CONTEXT_D3D10_DEVICE_KHR:                  ContextInfo read new ContextInfo($4014);
    public static property CONTEXT_D3D11_DEVICE_KHR:                  ContextInfo read new ContextInfo($401D);
    public static property CONTEXT_D3D9_DEVICE_INTEL:                 ContextInfo read new ContextInfo($4026);
    public static property CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR: ContextInfo read new ContextInfo($402C);
    public static property CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR: ContextInfo read new ContextInfo($402D);
    public static property CONTEXT_D3D9EX_DEVICE_INTEL:               ContextInfo read new ContextInfo($4072);
    public static property CONTEXT_DXVA_DEVICE_INTEL:                 ContextInfo read new ContextInfo($4073);
    public static property CONTEXT_VA_API_DISPLAY_INTEL:              ContextInfo read new ContextInfo($4097);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1080) then Result := 'CONTEXT_REFERENCE_COUNT' else
      if self.val = UInt32($1081) then Result := 'CONTEXT_DEVICES' else
      if self.val = UInt32($1082) then Result := 'CONTEXT_PROPERTIES' else
      if self.val = UInt32($1083) then Result := 'CONTEXT_NUM_DEVICES' else
      if self.val = UInt32($2025) then Result := 'CONTEXT_ADAPTER_D3D9_KHR' else
      if self.val = UInt32($2026) then Result := 'CONTEXT_ADAPTER_D3D9EX_KHR' else
      if self.val = UInt32($2027) then Result := 'CONTEXT_ADAPTER_DXVA_KHR' else
      if self.val = UInt32($4014) then Result := 'CONTEXT_D3D10_DEVICE_KHR' else
      if self.val = UInt32($401D) then Result := 'CONTEXT_D3D11_DEVICE_KHR' else
      if self.val = UInt32($4026) then Result := 'CONTEXT_D3D9_DEVICE_INTEL' else
      if self.val = UInt32($402C) then Result := 'CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR' else
      if self.val = UInt32($402D) then Result := 'CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR' else
      if self.val = UInt32($4072) then Result := 'CONTEXT_D3D9EX_DEVICE_INTEL' else
      if self.val = UInt32($4073) then Result := 'CONTEXT_DXVA_DEVICE_INTEL' else
      if self.val = UInt32($4097) then Result := 'CONTEXT_VA_API_DISPLAY_INTEL' else
        Result := $'ContextInfo[{self.val}]';
    end;
    
  end;
  
  ContextProperties = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public constructor(val: Int32) := self.val := new IntPtr(val);
    
    public static property CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL:    ContextProperties read new ContextProperties($0001);
    public static property CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL:     ContextProperties read new ContextProperties($0002);
    public static property CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL: ContextProperties read new ContextProperties($0004);
    public static property CONTEXT_DIAGNOSTICS_LEVEL_ALL_INTEL:     ContextProperties read new ContextProperties($00FF);
    public static property CONTEXT_PLATFORM:                        ContextProperties read new ContextProperties($1084);
    public static property CONTEXT_INTEROP_USER_SYNC:               ContextProperties read new ContextProperties($1085);
    public static property GL_CONTEXT_KHR:                          ContextProperties read new ContextProperties($2008);
    public static property EGL_DISPLAY_KHR:                         ContextProperties read new ContextProperties($2009);
    public static property GLX_DISPLAY_KHR:                         ContextProperties read new ContextProperties($200A);
    public static property WGL_HDC_KHR:                             ContextProperties read new ContextProperties($200B);
    public static property CGL_SHAREGROUP_KHR:                      ContextProperties read new ContextProperties($200C);
    public static property CONTEXT_TERMINATE_KHR:                   ContextProperties read new ContextProperties($2032);
    public static property PRINTF_CALLBACK_ARM:                     ContextProperties read new ContextProperties($40B0);
    public static property PRINTF_BUFFERSIZE_ARM:                   ContextProperties read new ContextProperties($40B1);
    public static property CONTEXT_SHOW_DIAGNOSTICS_INTEL:          ContextProperties read new ContextProperties($4106);
    
    public function ToString: string; override;
    begin
      if self.val = IntPtr($0001) then Result := 'CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL' else
      if self.val = IntPtr($0002) then Result := 'CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL' else
      if self.val = IntPtr($0004) then Result := 'CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL' else
      if self.val = IntPtr($00FF) then Result := 'CONTEXT_DIAGNOSTICS_LEVEL_ALL_INTEL' else
      if self.val = IntPtr($1084) then Result := 'CONTEXT_PLATFORM' else
      if self.val = IntPtr($1085) then Result := 'CONTEXT_INTEROP_USER_SYNC' else
      if self.val = IntPtr($2008) then Result := 'GL_CONTEXT_KHR' else
      if self.val = IntPtr($2009) then Result := 'EGL_DISPLAY_KHR' else
      if self.val = IntPtr($200A) then Result := 'GLX_DISPLAY_KHR' else
      if self.val = IntPtr($200B) then Result := 'WGL_HDC_KHR' else
      if self.val = IntPtr($200C) then Result := 'CGL_SHAREGROUP_KHR' else
      if self.val = IntPtr($2032) then Result := 'CONTEXT_TERMINATE_KHR' else
      if self.val = IntPtr($40B0) then Result := 'PRINTF_CALLBACK_ARM' else
      if self.val = IntPtr($40B1) then Result := 'PRINTF_BUFFERSIZE_ARM' else
      if self.val = IntPtr($4106) then Result := 'CONTEXT_SHOW_DIAGNOSTICS_INTEL' else
        Result := $'ContextProperties[{self.val}]';
    end;
    
  end;
  
  D3d10DeviceSetKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PREFERRED_DEVICES_FOR_D3D10_KHR: D3d10DeviceSetKhr read new D3d10DeviceSetKhr($4012);
    public static property ALL_DEVICES_FOR_D3D10_KHR:       D3d10DeviceSetKhr read new D3d10DeviceSetKhr($4013);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4012) then Result := 'PREFERRED_DEVICES_FOR_D3D10_KHR' else
      if self.val = UInt32($4013) then Result := 'ALL_DEVICES_FOR_D3D10_KHR' else
        Result := $'D3d10DeviceSetKhr[{self.val}]';
    end;
    
  end;
  
  D3d10DeviceSourceKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property D3D10_DEVICE_KHR:       D3d10DeviceSourceKhr read new D3d10DeviceSourceKhr($4010);
    public static property D3D10_DXGI_ADAPTER_KHR: D3d10DeviceSourceKhr read new D3d10DeviceSourceKhr($4011);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4010) then Result := 'D3D10_DEVICE_KHR' else
      if self.val = UInt32($4011) then Result := 'D3D10_DXGI_ADAPTER_KHR' else
        Result := $'D3d10DeviceSourceKhr[{self.val}]';
    end;
    
  end;
  
  D3d11DeviceSetKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PREFERRED_DEVICES_FOR_D3D11_KHR: D3d11DeviceSetKhr read new D3d11DeviceSetKhr($401B);
    public static property ALL_DEVICES_FOR_D3D11_KHR:       D3d11DeviceSetKhr read new D3d11DeviceSetKhr($401C);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($401B) then Result := 'PREFERRED_DEVICES_FOR_D3D11_KHR' else
      if self.val = UInt32($401C) then Result := 'ALL_DEVICES_FOR_D3D11_KHR' else
        Result := $'D3d11DeviceSetKhr[{self.val}]';
    end;
    
  end;
  
  D3d11DeviceSourceKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property D3D11_DEVICE_KHR:       D3d11DeviceSourceKhr read new D3d11DeviceSourceKhr($4019);
    public static property D3D11_DXGI_ADAPTER_KHR: D3d11DeviceSourceKhr read new D3d11DeviceSourceKhr($401A);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4019) then Result := 'D3D11_DEVICE_KHR' else
      if self.val = UInt32($401A) then Result := 'D3D11_DXGI_ADAPTER_KHR' else
        Result := $'D3d11DeviceSourceKhr[{self.val}]';
    end;
    
  end;
  
  DeviceAffinityDomain = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property DEVICE_AFFINITY_DOMAIN_NUMA:               DeviceAffinityDomain read new DeviceAffinityDomain($0001);
    public static property DEVICE_AFFINITY_DOMAIN_L4_CACHE:           DeviceAffinityDomain read new DeviceAffinityDomain($0002);
    public static property DEVICE_AFFINITY_DOMAIN_L3_CACHE:           DeviceAffinityDomain read new DeviceAffinityDomain($0004);
    public static property DEVICE_AFFINITY_DOMAIN_L2_CACHE:           DeviceAffinityDomain read new DeviceAffinityDomain($0008);
    public static property DEVICE_AFFINITY_DOMAIN_L1_CACHE:           DeviceAffinityDomain read new DeviceAffinityDomain($0010);
    public static property DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE: DeviceAffinityDomain read new DeviceAffinityDomain($0020);
    
    public static function operator+(f1,f2: DeviceAffinityDomain) := new DeviceAffinityDomain(f1.val or f2.val);
    public static function operator or(f1,f2: DeviceAffinityDomain) := f1+f2;
    
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_NUMA:               boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_L4_CACHE:           boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_L3_CACHE:           boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_L2_CACHE:           boolean read self.val and $0008 <> 0;
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_L1_CACHE:           boolean read self.val and $0010 <> 0;
    public property HAS_FLAG_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE: boolean read self.val and $0020 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'DEVICE_AFFINITY_DOMAIN_NUMA+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'DEVICE_AFFINITY_DOMAIN_L4_CACHE+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'DEVICE_AFFINITY_DOMAIN_L3_CACHE+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'DEVICE_AFFINITY_DOMAIN_L2_CACHE+';
      if self.val and UInt64($0010) = UInt64($0010) then res += 'DEVICE_AFFINITY_DOMAIN_L1_CACHE+';
      if self.val and UInt64($0020) = UInt64($0020) then res += 'DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'DeviceAffinityDomain[{self.val}]';
    end;
    
  end;
  
  DeviceExecCapabilities = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property EXEC_KERNEL:        DeviceExecCapabilities read new DeviceExecCapabilities($0001);
    public static property EXEC_NATIVE_KERNEL: DeviceExecCapabilities read new DeviceExecCapabilities($0002);
    
    public static function operator+(f1,f2: DeviceExecCapabilities) := new DeviceExecCapabilities(f1.val or f2.val);
    public static function operator or(f1,f2: DeviceExecCapabilities) := f1+f2;
    
    public property HAS_FLAG_EXEC_KERNEL:        boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_EXEC_NATIVE_KERNEL: boolean read self.val and $0002 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'EXEC_KERNEL+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'EXEC_NATIVE_KERNEL+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'DeviceExecCapabilities[{self.val}]';
    end;
    
  end;
  
  DeviceFPConfig = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property FP_DENORM:                        DeviceFPConfig read new DeviceFPConfig($0001);
    public static property FP_INF_NAN:                       DeviceFPConfig read new DeviceFPConfig($0002);
    public static property FP_ROUND_TO_NEAREST:              DeviceFPConfig read new DeviceFPConfig($0004);
    public static property FP_ROUND_TO_ZERO:                 DeviceFPConfig read new DeviceFPConfig($0008);
    public static property FP_ROUND_TO_INF:                  DeviceFPConfig read new DeviceFPConfig($0010);
    public static property FP_FMA:                           DeviceFPConfig read new DeviceFPConfig($0020);
    public static property FP_SOFT_FLOAT:                    DeviceFPConfig read new DeviceFPConfig($0040);
    public static property FP_CORRECTLY_ROUNDED_DIVIDE_SQRT: DeviceFPConfig read new DeviceFPConfig($0080);
    
    public static function operator+(f1,f2: DeviceFPConfig) := new DeviceFPConfig(f1.val or f2.val);
    public static function operator or(f1,f2: DeviceFPConfig) := f1+f2;
    
    public property HAS_FLAG_FP_DENORM:                        boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_FP_INF_NAN:                       boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_FP_ROUND_TO_NEAREST:              boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_FP_ROUND_TO_ZERO:                 boolean read self.val and $0008 <> 0;
    public property HAS_FLAG_FP_ROUND_TO_INF:                  boolean read self.val and $0010 <> 0;
    public property HAS_FLAG_FP_FMA:                           boolean read self.val and $0020 <> 0;
    public property HAS_FLAG_FP_SOFT_FLOAT:                    boolean read self.val and $0040 <> 0;
    public property HAS_FLAG_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT: boolean read self.val and $0080 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'FP_DENORM+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'FP_INF_NAN+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'FP_ROUND_TO_NEAREST+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'FP_ROUND_TO_ZERO+';
      if self.val and UInt64($0010) = UInt64($0010) then res += 'FP_ROUND_TO_INF+';
      if self.val and UInt64($0020) = UInt64($0020) then res += 'FP_FMA+';
      if self.val and UInt64($0040) = UInt64($0040) then res += 'FP_SOFT_FLOAT+';
      if self.val and UInt64($0080) = UInt64($0080) then res += 'FP_CORRECTLY_ROUNDED_DIVIDE_SQRT+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'DeviceFPConfig[{self.val}]';
    end;
    
  end;
  
  DeviceInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property DEVICE_TYPE:                                                          DeviceInfo read new DeviceInfo($1000);
    public static property DEVICE_VENDOR_ID:                                                     DeviceInfo read new DeviceInfo($1001);
    public static property DEVICE_MAX_COMPUTE_UNITS:                                             DeviceInfo read new DeviceInfo($1002);
    public static property DEVICE_MAX_WORK_ITEM_DIMENSIONS:                                      DeviceInfo read new DeviceInfo($1003);
    public static property DEVICE_MAX_WORK_GROUP_SIZE:                                           DeviceInfo read new DeviceInfo($1004);
    public static property DEVICE_MAX_WORK_ITEM_SIZES:                                           DeviceInfo read new DeviceInfo($1005);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_CHAR:                                   DeviceInfo read new DeviceInfo($1006);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_SHORT:                                  DeviceInfo read new DeviceInfo($1007);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_INT:                                    DeviceInfo read new DeviceInfo($1008);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_LONG:                                   DeviceInfo read new DeviceInfo($1009);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT:                                  DeviceInfo read new DeviceInfo($100A);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE:                                 DeviceInfo read new DeviceInfo($100B);
    public static property DEVICE_MAX_CLOCK_FREQUENCY:                                           DeviceInfo read new DeviceInfo($100C);
    public static property DEVICE_ADDRESS_BITS:                                                  DeviceInfo read new DeviceInfo($100D);
    public static property DEVICE_MAX_READ_IMAGE_ARGS:                                           DeviceInfo read new DeviceInfo($100E);
    public static property DEVICE_MAX_WRITE_IMAGE_ARGS:                                          DeviceInfo read new DeviceInfo($100F);
    public static property DEVICE_MAX_MEM_ALLOC_SIZE:                                            DeviceInfo read new DeviceInfo($1010);
    public static property DEVICE_IMAGE2D_MAX_WIDTH:                                             DeviceInfo read new DeviceInfo($1011);
    public static property DEVICE_IMAGE2D_MAX_HEIGHT:                                            DeviceInfo read new DeviceInfo($1012);
    public static property DEVICE_IMAGE3D_MAX_WIDTH:                                             DeviceInfo read new DeviceInfo($1013);
    public static property DEVICE_IMAGE3D_MAX_HEIGHT:                                            DeviceInfo read new DeviceInfo($1014);
    public static property DEVICE_IMAGE3D_MAX_DEPTH:                                             DeviceInfo read new DeviceInfo($1015);
    public static property DEVICE_IMAGE_SUPPORT:                                                 DeviceInfo read new DeviceInfo($1016);
    public static property DEVICE_MAX_PARAMETER_SIZE:                                            DeviceInfo read new DeviceInfo($1017);
    public static property DEVICE_MAX_SAMPLERS:                                                  DeviceInfo read new DeviceInfo($1018);
    public static property DEVICE_MEM_BASE_ADDR_ALIGN:                                           DeviceInfo read new DeviceInfo($1019);
    public static property DEVICE_MIN_DATA_TYPE_ALIGN_SIZE:                                      DeviceInfo read new DeviceInfo($101A);
    public static property DEVICE_SINGLE_FP_CONFIG:                                              DeviceInfo read new DeviceInfo($101B);
    public static property DEVICE_GLOBAL_MEM_CACHE_TYPE:                                         DeviceInfo read new DeviceInfo($101C);
    public static property DEVICE_GLOBAL_MEM_CACHELINE_SIZE:                                     DeviceInfo read new DeviceInfo($101D);
    public static property DEVICE_GLOBAL_MEM_CACHE_SIZE:                                         DeviceInfo read new DeviceInfo($101E);
    public static property DEVICE_GLOBAL_MEM_SIZE:                                               DeviceInfo read new DeviceInfo($101F);
    public static property DEVICE_MAX_CONSTANT_BUFFER_SIZE:                                      DeviceInfo read new DeviceInfo($1020);
    public static property DEVICE_MAX_CONSTANT_ARGS:                                             DeviceInfo read new DeviceInfo($1021);
    public static property DEVICE_LOCAL_MEM_TYPE:                                                DeviceInfo read new DeviceInfo($1022);
    public static property DEVICE_LOCAL_MEM_SIZE:                                                DeviceInfo read new DeviceInfo($1023);
    public static property DEVICE_ERROR_CORRECTION_SUPPORT:                                      DeviceInfo read new DeviceInfo($1024);
    public static property DEVICE_PROFILING_TIMER_RESOLUTION:                                    DeviceInfo read new DeviceInfo($1025);
    public static property DEVICE_ENDIAN_LITTLE:                                                 DeviceInfo read new DeviceInfo($1026);
    public static property DEVICE_AVAILABLE:                                                     DeviceInfo read new DeviceInfo($1027);
    public static property DEVICE_COMPILER_AVAILABLE:                                            DeviceInfo read new DeviceInfo($1028);
    public static property DEVICE_EXECUTION_CAPABILITIES:                                        DeviceInfo read new DeviceInfo($1029);
    public static property DEVICE_QUEUE_ON_HOST_PROPERTIES:                                      DeviceInfo read new DeviceInfo($102A);
    public static property DEVICE_QUEUE_PROPERTIES:                                              DeviceInfo read new DeviceInfo($102A);
    public static property DEVICE_NAME:                                                          DeviceInfo read new DeviceInfo($102B);
    public static property DEVICE_VENDOR:                                                        DeviceInfo read new DeviceInfo($102C);
    public static property DRIVER_VERSION:                                                       DeviceInfo read new DeviceInfo($102D);
    public static property DEVICE_PROFILE:                                                       DeviceInfo read new DeviceInfo($102E);
    public static property DEVICE_VERSION:                                                       DeviceInfo read new DeviceInfo($102F);
    public static property DEVICE_EXTENSIONS:                                                    DeviceInfo read new DeviceInfo($1030);
    public static property DEVICE_PLATFORM:                                                      DeviceInfo read new DeviceInfo($1031);
    public static property DEVICE_DOUBLE_FP_CONFIG:                                              DeviceInfo read new DeviceInfo($1032);
    public static property DEVICE_HALF_FP_CONFIG:                                                DeviceInfo read new DeviceInfo($1033);
    public static property DEVICE_PREFERRED_VECTOR_WIDTH_HALF:                                   DeviceInfo read new DeviceInfo($1034);
    public static property DEVICE_HOST_UNIFIED_MEMORY:                                           DeviceInfo read new DeviceInfo($1035);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_CHAR:                                      DeviceInfo read new DeviceInfo($1036);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_SHORT:                                     DeviceInfo read new DeviceInfo($1037);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_INT:                                       DeviceInfo read new DeviceInfo($1038);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_LONG:                                      DeviceInfo read new DeviceInfo($1039);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_FLOAT:                                     DeviceInfo read new DeviceInfo($103A);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE:                                    DeviceInfo read new DeviceInfo($103B);
    public static property DEVICE_NATIVE_VECTOR_WIDTH_HALF:                                      DeviceInfo read new DeviceInfo($103C);
    public static property DEVICE_OPENCL_C_VERSION:                                              DeviceInfo read new DeviceInfo($103D);
    public static property DEVICE_LINKER_AVAILABLE:                                              DeviceInfo read new DeviceInfo($103E);
    public static property DEVICE_BUILT_IN_KERNELS:                                              DeviceInfo read new DeviceInfo($103F);
    public static property DEVICE_IMAGE_MAX_BUFFER_SIZE:                                         DeviceInfo read new DeviceInfo($1040);
    public static property DEVICE_IMAGE_MAX_ARRAY_SIZE:                                          DeviceInfo read new DeviceInfo($1041);
    public static property DEVICE_PARENT_DEVICE:                                                 DeviceInfo read new DeviceInfo($1042);
    public static property DEVICE_PARTITION_MAX_SUB_DEVICES:                                     DeviceInfo read new DeviceInfo($1043);
    public static property DEVICE_PARTITION_PROPERTIES:                                          DeviceInfo read new DeviceInfo($1044);
    public static property DEVICE_PARTITION_AFFINITY_DOMAIN:                                     DeviceInfo read new DeviceInfo($1045);
    public static property DEVICE_PARTITION_TYPE:                                                DeviceInfo read new DeviceInfo($1046);
    public static property DEVICE_REFERENCE_COUNT:                                               DeviceInfo read new DeviceInfo($1047);
    public static property DEVICE_PREFERRED_INTEROP_USER_SYNC:                                   DeviceInfo read new DeviceInfo($1048);
    public static property DEVICE_PRINTF_BUFFER_SIZE:                                            DeviceInfo read new DeviceInfo($1049);
    public static property DEVICE_IMAGE_PITCH_ALIGNMENT:                                         DeviceInfo read new DeviceInfo($104A);
    public static property DEVICE_IMAGE_PITCH_ALIGNMENT_KHR:                                     DeviceInfo read new DeviceInfo($104A);
    public static property DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT:                                  DeviceInfo read new DeviceInfo($104B);
    public static property DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR:                              DeviceInfo read new DeviceInfo($104B);
    public static property DEVICE_MAX_READ_WRITE_IMAGE_ARGS:                                     DeviceInfo read new DeviceInfo($104C);
    public static property DEVICE_MAX_GLOBAL_VARIABLE_SIZE:                                      DeviceInfo read new DeviceInfo($104D);
    public static property DEVICE_QUEUE_ON_DEVICE_PROPERTIES:                                    DeviceInfo read new DeviceInfo($104E);
    public static property DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE:                                DeviceInfo read new DeviceInfo($104F);
    public static property DEVICE_QUEUE_ON_DEVICE_MAX_SIZE:                                      DeviceInfo read new DeviceInfo($1050);
    public static property DEVICE_MAX_ON_DEVICE_QUEUES:                                          DeviceInfo read new DeviceInfo($1051);
    public static property DEVICE_MAX_ON_DEVICE_EVENTS:                                          DeviceInfo read new DeviceInfo($1052);
    public static property DEVICE_SVM_CAPABILITIES:                                              DeviceInfo read new DeviceInfo($1053);
    public static property DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE:                          DeviceInfo read new DeviceInfo($1054);
    public static property DEVICE_MAX_PIPE_ARGS:                                                 DeviceInfo read new DeviceInfo($1055);
    public static property DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS:                                  DeviceInfo read new DeviceInfo($1056);
    public static property DEVICE_PIPE_MAX_PACKET_SIZE:                                          DeviceInfo read new DeviceInfo($1057);
    public static property DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT:                           DeviceInfo read new DeviceInfo($1058);
    public static property DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT:                             DeviceInfo read new DeviceInfo($1059);
    public static property DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT:                              DeviceInfo read new DeviceInfo($105A);
    public static property DEVICE_IL_VERSION:                                                    DeviceInfo read new DeviceInfo($105B);
    public static property DEVICE_IL_VERSION_KHR:                                                DeviceInfo read new DeviceInfo($105B);
    public static property DEVICE_MAX_NUM_SUB_GROUPS:                                            DeviceInfo read new DeviceInfo($105C);
    public static property DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS:                        DeviceInfo read new DeviceInfo($105D);
    public static property DEVICE_NUMERIC_VERSION:                                               DeviceInfo read new DeviceInfo($105E);
    public static property DEVICE_NUMERIC_VERSION_KHR:                                           DeviceInfo read new DeviceInfo($105E);
    public static property DEVICE_OPENCL_C_NUMERIC_VERSION_KHR:                                  DeviceInfo read new DeviceInfo($105F);
    public static property DEVICE_EXTENSIONS_WITH_VERSION:                                       DeviceInfo read new DeviceInfo($1060);
    public static property DEVICE_EXTENSIONS_WITH_VERSION_KHR:                                   DeviceInfo read new DeviceInfo($1060);
    public static property DEVICE_ILS_WITH_VERSION:                                              DeviceInfo read new DeviceInfo($1061);
    public static property DEVICE_ILS_WITH_VERSION_KHR:                                          DeviceInfo read new DeviceInfo($1061);
    public static property DEVICE_BUILT_IN_KERNELS_WITH_VERSION:                                 DeviceInfo read new DeviceInfo($1062);
    public static property DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR:                             DeviceInfo read new DeviceInfo($1062);
    public static property DEVICE_ATOMIC_MEMORY_CAPABILITIES:                                    DeviceInfo read new DeviceInfo($1063);
    public static property DEVICE_ATOMIC_FENCE_CAPABILITIES:                                     DeviceInfo read new DeviceInfo($1064);
    public static property DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT:                                DeviceInfo read new DeviceInfo($1065);
    public static property DEVICE_OPENCL_C_ALL_VERSIONS:                                         DeviceInfo read new DeviceInfo($1066);
    public static property DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE:                            DeviceInfo read new DeviceInfo($1067);
    public static property DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT:                       DeviceInfo read new DeviceInfo($1068);
    public static property DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT:                                 DeviceInfo read new DeviceInfo($1069);
    public static property DEVICE_UUID_KHR:                                                      DeviceInfo read new DeviceInfo($106A);
    public static property DRIVER_UUID_KHR:                                                      DeviceInfo read new DeviceInfo($106B);
    public static property DEVICE_LUID_VALID_KHR:                                                DeviceInfo read new DeviceInfo($106C);
    public static property DEVICE_LUID_KHR:                                                      DeviceInfo read new DeviceInfo($106D);
    public static property DEVICE_NODE_MASK_KHR:                                                 DeviceInfo read new DeviceInfo($106E);
    public static property DEVICE_OPENCL_C_FEATURES:                                             DeviceInfo read new DeviceInfo($106F);
    public static property DEVICE_DEVICE_ENQUEUE_CAPABILITIES:                                   DeviceInfo read new DeviceInfo($1070);
    public static property DEVICE_PIPE_SUPPORT:                                                  DeviceInfo read new DeviceInfo($1071);
    public static property DEVICE_LATEST_CONFORMANCE_VERSION_PASSED:                             DeviceInfo read new DeviceInfo($1072);
    public static property DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR:                          DeviceInfo read new DeviceInfo($1073);
    public static property DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR:          DeviceInfo read new DeviceInfo($1074);
    public static property DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR: DeviceInfo read new DeviceInfo($1075);
    public static property DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR:                               DeviceInfo read new DeviceInfo($12A9);
    public static property DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR:                  DeviceInfo read new DeviceInfo($12AA);
    public static property DEVICE_TERMINATE_CAPABILITY_KHR:                                      DeviceInfo read new DeviceInfo($2031);
    public static property DEVICE_MAX_NAMED_BARRIER_COUNT_KHR:                                   DeviceInfo read new DeviceInfo($2035);
    public static property DEVICE_SEMAPHORE_TYPES_KHR:                                           DeviceInfo read new DeviceInfo($204C);
    public static property DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR:                             DeviceInfo read new DeviceInfo($204D);
    public static property DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR:                             DeviceInfo read new DeviceInfo($204E);
    public static property DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR:                       DeviceInfo read new DeviceInfo($204F);
    public static property DEVICE_COMPUTE_CAPABILITY_MAJOR_NV:                                   DeviceInfo read new DeviceInfo($4000);
    public static property DEVICE_COMPUTE_CAPABILITY_MINOR_NV:                                   DeviceInfo read new DeviceInfo($4001);
    public static property DEVICE_REGISTERS_PER_BLOCK_NV:                                        DeviceInfo read new DeviceInfo($4002);
    public static property DEVICE_WARP_SIZE_NV:                                                  DeviceInfo read new DeviceInfo($4003);
    public static property DEVICE_GPU_OVERLAP_NV:                                                DeviceInfo read new DeviceInfo($4004);
    public static property DEVICE_KERNEL_EXEC_TIMEOUT_NV:                                        DeviceInfo read new DeviceInfo($4005);
    public static property DEVICE_INTEGRATED_MEMORY_NV:                                          DeviceInfo read new DeviceInfo($4006);
    public static property DEVICE_PREFERRED_WORK_GROUP_SIZE_AMD:                                 DeviceInfo read new DeviceInfo($4030);
    public static property DEVICE_MAX_WORK_GROUP_SIZE_AMD:                                       DeviceInfo read new DeviceInfo($4031);
    public static property DEVICE_PREFERRED_CONSTANT_BUFFER_SIZE_AMD:                            DeviceInfo read new DeviceInfo($4033);
    public static property DEVICE_PCIE_ID_AMD:                                                   DeviceInfo read new DeviceInfo($4034);
    public static property DEVICE_PROFILING_TIMER_OFFSET_AMD:                                    DeviceInfo read new DeviceInfo($4036);
    public static property DEVICE_TOPOLOGY_AMD:                                                  DeviceInfo read new DeviceInfo($4037);
    public static property DEVICE_BOARD_NAME_AMD:                                                DeviceInfo read new DeviceInfo($4038);
    public static property DEVICE_GLOBAL_FREE_MEMORY_AMD:                                        DeviceInfo read new DeviceInfo($4039);
    public static property DEVICE_SIMD_PER_COMPUTE_UNIT_AMD:                                     DeviceInfo read new DeviceInfo($4040);
    public static property DEVICE_SIMD_WIDTH_AMD:                                                DeviceInfo read new DeviceInfo($4041);
    public static property DEVICE_SIMD_INSTRUCTION_WIDTH_AMD:                                    DeviceInfo read new DeviceInfo($4042);
    public static property DEVICE_WAVEFRONT_WIDTH_AMD:                                           DeviceInfo read new DeviceInfo($4043);
    public static property DEVICE_GLOBAL_MEM_CHANNELS_AMD:                                       DeviceInfo read new DeviceInfo($4044);
    public static property DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD:                                  DeviceInfo read new DeviceInfo($4045);
    public static property DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD:                             DeviceInfo read new DeviceInfo($4046);
    public static property DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD:                           DeviceInfo read new DeviceInfo($4047);
    public static property DEVICE_LOCAL_MEM_BANKS_AMD:                                           DeviceInfo read new DeviceInfo($4048);
    public static property DEVICE_THREAD_TRACE_SUPPORTED_AMD:                                    DeviceInfo read new DeviceInfo($4049);
    public static property DEVICE_GFXIP_MAJOR_AMD:                                               DeviceInfo read new DeviceInfo($404A);
    public static property DEVICE_GFXIP_MINOR_AMD:                                               DeviceInfo read new DeviceInfo($404B);
    public static property DEVICE_AVAILABLE_ASYNC_QUEUES_AMD:                                    DeviceInfo read new DeviceInfo($404C);
    public static property DEVICE_PARENT_DEVICE_EXT:                                             DeviceInfo read new DeviceInfo($4054);
    public static property DEVICE_PARTITION_TYPES_EXT:                                           DeviceInfo read new DeviceInfo($4055);
    public static property DEVICE_AFFINITY_DOMAINS_EXT:                                          DeviceInfo read new DeviceInfo($4056);
    public static property DEVICE_REFERENCE_COUNT_EXT:                                           DeviceInfo read new DeviceInfo($4057);
    public static property DEVICE_PARTITION_STYLE_EXT:                                           DeviceInfo read new DeviceInfo($4058);
    public static property DEVICE_ME_VERSION_INTEL:                                              DeviceInfo read new DeviceInfo($407E);
    public static property DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM:                                 DeviceInfo read new DeviceInfo($40A0);
    public static property DEVICE_PAGE_SIZE_QCOM:                                                DeviceInfo read new DeviceInfo($40A1);
    public static property DEVICE_SVM_CAPABILITIES_ARM:                                          DeviceInfo read new DeviceInfo($40B6);
    public static property DEVICE_COMPUTE_UNITS_BITFIELD_ARM:                                    DeviceInfo read new DeviceInfo($40BF);
    public static property DEVICE_SPIR_VERSIONS:                                                 DeviceInfo read new DeviceInfo($40E0);
    public static property DEVICE_SIMULTANEOUS_INTEROPS_INTEL:                                   DeviceInfo read new DeviceInfo($4104);
    public static property DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL:                               DeviceInfo read new DeviceInfo($4105);
    public static property DEVICE_SUB_GROUP_SIZES_INTEL:                                         DeviceInfo read new DeviceInfo($4108);
    public static property DEVICE_AVC_ME_VERSION_INTEL:                                          DeviceInfo read new DeviceInfo($410B);
    public static property DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL:                     DeviceInfo read new DeviceInfo($410C);
    public static property DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL:                              DeviceInfo read new DeviceInfo($410D);
    public static property DEVICE_PCI_BUS_INFO_KHR:                                              DeviceInfo read new DeviceInfo($410F);
    public static property DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL:                                    DeviceInfo read new DeviceInfo($417E);
    public static property DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL:                                   DeviceInfo read new DeviceInfo($417F);
    public static property DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL:                                 DeviceInfo read new DeviceInfo($418B);
    public static property DEVICE_HOST_MEM_CAPABILITIES_INTEL:                                   DeviceInfo read new DeviceInfo($4190);
    public static property DEVICE_DEVICE_MEM_CAPABILITIES_INTEL:                                 DeviceInfo read new DeviceInfo($4191);
    public static property DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL:                   DeviceInfo read new DeviceInfo($4192);
    public static property DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL:                    DeviceInfo read new DeviceInfo($4193);
    public static property DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL:                          DeviceInfo read new DeviceInfo($4194);
    public static property DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM:                          DeviceInfo read new DeviceInfo($41E4);
    public static property DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM:                            DeviceInfo read new DeviceInfo($41EB);
    public static property DEVICE_CONTROLLED_TERMINATION_CAPABILITIES_ARM:                       DeviceInfo read new DeviceInfo($41EE);
    public static property DEVICE_CXX_FOR_OPENCL_NUMERIC_VERSION_EXT:                            DeviceInfo read new DeviceInfo($4230);
    public static property DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT:                             DeviceInfo read new DeviceInfo($4231);
    public static property DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT:                             DeviceInfo read new DeviceInfo($4232);
    public static property DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT:                               DeviceInfo read new DeviceInfo($4233);
    public static property DEVICE_IP_VERSION_INTEL:                                              DeviceInfo read new DeviceInfo($4250);
    public static property DEVICE_ID_INTEL:                                                      DeviceInfo read new DeviceInfo($4251);
    public static property DEVICE_NUM_SLICES_INTEL:                                              DeviceInfo read new DeviceInfo($4252);
    public static property DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL:                                DeviceInfo read new DeviceInfo($4253);
    public static property DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL:                                   DeviceInfo read new DeviceInfo($4254);
    public static property DEVICE_NUM_THREADS_PER_EU_INTEL:                                      DeviceInfo read new DeviceInfo($4255);
    public static property DEVICE_FEATURE_CAPABILITIES_INTEL:                                    DeviceInfo read new DeviceInfo($4256);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1000) then Result := 'DEVICE_TYPE' else
      if self.val = UInt32($1001) then Result := 'DEVICE_VENDOR_ID' else
      if self.val = UInt32($1002) then Result := 'DEVICE_MAX_COMPUTE_UNITS' else
      if self.val = UInt32($1003) then Result := 'DEVICE_MAX_WORK_ITEM_DIMENSIONS' else
      if self.val = UInt32($1004) then Result := 'DEVICE_MAX_WORK_GROUP_SIZE' else
      if self.val = UInt32($1005) then Result := 'DEVICE_MAX_WORK_ITEM_SIZES' else
      if self.val = UInt32($1006) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_CHAR' else
      if self.val = UInt32($1007) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_SHORT' else
      if self.val = UInt32($1008) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_INT' else
      if self.val = UInt32($1009) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_LONG' else
      if self.val = UInt32($100A) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT' else
      if self.val = UInt32($100B) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE' else
      if self.val = UInt32($100C) then Result := 'DEVICE_MAX_CLOCK_FREQUENCY' else
      if self.val = UInt32($100D) then Result := 'DEVICE_ADDRESS_BITS' else
      if self.val = UInt32($100E) then Result := 'DEVICE_MAX_READ_IMAGE_ARGS' else
      if self.val = UInt32($100F) then Result := 'DEVICE_MAX_WRITE_IMAGE_ARGS' else
      if self.val = UInt32($1010) then Result := 'DEVICE_MAX_MEM_ALLOC_SIZE' else
      if self.val = UInt32($1011) then Result := 'DEVICE_IMAGE2D_MAX_WIDTH' else
      if self.val = UInt32($1012) then Result := 'DEVICE_IMAGE2D_MAX_HEIGHT' else
      if self.val = UInt32($1013) then Result := 'DEVICE_IMAGE3D_MAX_WIDTH' else
      if self.val = UInt32($1014) then Result := 'DEVICE_IMAGE3D_MAX_HEIGHT' else
      if self.val = UInt32($1015) then Result := 'DEVICE_IMAGE3D_MAX_DEPTH' else
      if self.val = UInt32($1016) then Result := 'DEVICE_IMAGE_SUPPORT' else
      if self.val = UInt32($1017) then Result := 'DEVICE_MAX_PARAMETER_SIZE' else
      if self.val = UInt32($1018) then Result := 'DEVICE_MAX_SAMPLERS' else
      if self.val = UInt32($1019) then Result := 'DEVICE_MEM_BASE_ADDR_ALIGN' else
      if self.val = UInt32($101A) then Result := 'DEVICE_MIN_DATA_TYPE_ALIGN_SIZE' else
      if self.val = UInt32($101B) then Result := 'DEVICE_SINGLE_FP_CONFIG' else
      if self.val = UInt32($101C) then Result := 'DEVICE_GLOBAL_MEM_CACHE_TYPE' else
      if self.val = UInt32($101D) then Result := 'DEVICE_GLOBAL_MEM_CACHELINE_SIZE' else
      if self.val = UInt32($101E) then Result := 'DEVICE_GLOBAL_MEM_CACHE_SIZE' else
      if self.val = UInt32($101F) then Result := 'DEVICE_GLOBAL_MEM_SIZE' else
      if self.val = UInt32($1020) then Result := 'DEVICE_MAX_CONSTANT_BUFFER_SIZE' else
      if self.val = UInt32($1021) then Result := 'DEVICE_MAX_CONSTANT_ARGS' else
      if self.val = UInt32($1022) then Result := 'DEVICE_LOCAL_MEM_TYPE' else
      if self.val = UInt32($1023) then Result := 'DEVICE_LOCAL_MEM_SIZE' else
      if self.val = UInt32($1024) then Result := 'DEVICE_ERROR_CORRECTION_SUPPORT' else
      if self.val = UInt32($1025) then Result := 'DEVICE_PROFILING_TIMER_RESOLUTION' else
      if self.val = UInt32($1026) then Result := 'DEVICE_ENDIAN_LITTLE' else
      if self.val = UInt32($1027) then Result := 'DEVICE_AVAILABLE' else
      if self.val = UInt32($1028) then Result := 'DEVICE_COMPILER_AVAILABLE' else
      if self.val = UInt32($1029) then Result := 'DEVICE_EXECUTION_CAPABILITIES' else
      if self.val = UInt32($102A) then Result := 'DEVICE_QUEUE_ON_HOST_PROPERTIES' else
      if self.val = UInt32($102A) then Result := 'DEVICE_QUEUE_PROPERTIES' else
      if self.val = UInt32($102B) then Result := 'DEVICE_NAME' else
      if self.val = UInt32($102C) then Result := 'DEVICE_VENDOR' else
      if self.val = UInt32($102D) then Result := 'DRIVER_VERSION' else
      if self.val = UInt32($102E) then Result := 'DEVICE_PROFILE' else
      if self.val = UInt32($102F) then Result := 'DEVICE_VERSION' else
      if self.val = UInt32($1030) then Result := 'DEVICE_EXTENSIONS' else
      if self.val = UInt32($1031) then Result := 'DEVICE_PLATFORM' else
      if self.val = UInt32($1032) then Result := 'DEVICE_DOUBLE_FP_CONFIG' else
      if self.val = UInt32($1033) then Result := 'DEVICE_HALF_FP_CONFIG' else
      if self.val = UInt32($1034) then Result := 'DEVICE_PREFERRED_VECTOR_WIDTH_HALF' else
      if self.val = UInt32($1035) then Result := 'DEVICE_HOST_UNIFIED_MEMORY' else
      if self.val = UInt32($1036) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_CHAR' else
      if self.val = UInt32($1037) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_SHORT' else
      if self.val = UInt32($1038) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_INT' else
      if self.val = UInt32($1039) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_LONG' else
      if self.val = UInt32($103A) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_FLOAT' else
      if self.val = UInt32($103B) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE' else
      if self.val = UInt32($103C) then Result := 'DEVICE_NATIVE_VECTOR_WIDTH_HALF' else
      if self.val = UInt32($103D) then Result := 'DEVICE_OPENCL_C_VERSION' else
      if self.val = UInt32($103E) then Result := 'DEVICE_LINKER_AVAILABLE' else
      if self.val = UInt32($103F) then Result := 'DEVICE_BUILT_IN_KERNELS' else
      if self.val = UInt32($1040) then Result := 'DEVICE_IMAGE_MAX_BUFFER_SIZE' else
      if self.val = UInt32($1041) then Result := 'DEVICE_IMAGE_MAX_ARRAY_SIZE' else
      if self.val = UInt32($1042) then Result := 'DEVICE_PARENT_DEVICE' else
      if self.val = UInt32($1043) then Result := 'DEVICE_PARTITION_MAX_SUB_DEVICES' else
      if self.val = UInt32($1044) then Result := 'DEVICE_PARTITION_PROPERTIES' else
      if self.val = UInt32($1045) then Result := 'DEVICE_PARTITION_AFFINITY_DOMAIN' else
      if self.val = UInt32($1046) then Result := 'DEVICE_PARTITION_TYPE' else
      if self.val = UInt32($1047) then Result := 'DEVICE_REFERENCE_COUNT' else
      if self.val = UInt32($1048) then Result := 'DEVICE_PREFERRED_INTEROP_USER_SYNC' else
      if self.val = UInt32($1049) then Result := 'DEVICE_PRINTF_BUFFER_SIZE' else
      if self.val = UInt32($104A) then Result := 'DEVICE_IMAGE_PITCH_ALIGNMENT' else
      if self.val = UInt32($104A) then Result := 'DEVICE_IMAGE_PITCH_ALIGNMENT_KHR' else
      if self.val = UInt32($104B) then Result := 'DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT' else
      if self.val = UInt32($104B) then Result := 'DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR' else
      if self.val = UInt32($104C) then Result := 'DEVICE_MAX_READ_WRITE_IMAGE_ARGS' else
      if self.val = UInt32($104D) then Result := 'DEVICE_MAX_GLOBAL_VARIABLE_SIZE' else
      if self.val = UInt32($104E) then Result := 'DEVICE_QUEUE_ON_DEVICE_PROPERTIES' else
      if self.val = UInt32($104F) then Result := 'DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE' else
      if self.val = UInt32($1050) then Result := 'DEVICE_QUEUE_ON_DEVICE_MAX_SIZE' else
      if self.val = UInt32($1051) then Result := 'DEVICE_MAX_ON_DEVICE_QUEUES' else
      if self.val = UInt32($1052) then Result := 'DEVICE_MAX_ON_DEVICE_EVENTS' else
      if self.val = UInt32($1053) then Result := 'DEVICE_SVM_CAPABILITIES' else
      if self.val = UInt32($1054) then Result := 'DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE' else
      if self.val = UInt32($1055) then Result := 'DEVICE_MAX_PIPE_ARGS' else
      if self.val = UInt32($1056) then Result := 'DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS' else
      if self.val = UInt32($1057) then Result := 'DEVICE_PIPE_MAX_PACKET_SIZE' else
      if self.val = UInt32($1058) then Result := 'DEVICE_PREFERRED_PLATFORM_ATOMIC_ALIGNMENT' else
      if self.val = UInt32($1059) then Result := 'DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT' else
      if self.val = UInt32($105A) then Result := 'DEVICE_PREFERRED_LOCAL_ATOMIC_ALIGNMENT' else
      if self.val = UInt32($105B) then Result := 'DEVICE_IL_VERSION' else
      if self.val = UInt32($105B) then Result := 'DEVICE_IL_VERSION_KHR' else
      if self.val = UInt32($105C) then Result := 'DEVICE_MAX_NUM_SUB_GROUPS' else
      if self.val = UInt32($105D) then Result := 'DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS' else
      if self.val = UInt32($105E) then Result := 'DEVICE_NUMERIC_VERSION' else
      if self.val = UInt32($105E) then Result := 'DEVICE_NUMERIC_VERSION_KHR' else
      if self.val = UInt32($105F) then Result := 'DEVICE_OPENCL_C_NUMERIC_VERSION_KHR' else
      if self.val = UInt32($1060) then Result := 'DEVICE_EXTENSIONS_WITH_VERSION' else
      if self.val = UInt32($1060) then Result := 'DEVICE_EXTENSIONS_WITH_VERSION_KHR' else
      if self.val = UInt32($1061) then Result := 'DEVICE_ILS_WITH_VERSION' else
      if self.val = UInt32($1061) then Result := 'DEVICE_ILS_WITH_VERSION_KHR' else
      if self.val = UInt32($1062) then Result := 'DEVICE_BUILT_IN_KERNELS_WITH_VERSION' else
      if self.val = UInt32($1062) then Result := 'DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR' else
      if self.val = UInt32($1063) then Result := 'DEVICE_ATOMIC_MEMORY_CAPABILITIES' else
      if self.val = UInt32($1064) then Result := 'DEVICE_ATOMIC_FENCE_CAPABILITIES' else
      if self.val = UInt32($1065) then Result := 'DEVICE_NON_UNIFORM_WORK_GROUP_SUPPORT' else
      if self.val = UInt32($1066) then Result := 'DEVICE_OPENCL_C_ALL_VERSIONS' else
      if self.val = UInt32($1067) then Result := 'DEVICE_PREFERRED_WORK_GROUP_SIZE_MULTIPLE' else
      if self.val = UInt32($1068) then Result := 'DEVICE_WORK_GROUP_COLLECTIVE_FUNCTIONS_SUPPORT' else
      if self.val = UInt32($1069) then Result := 'DEVICE_GENERIC_ADDRESS_SPACE_SUPPORT' else
      if self.val = UInt32($106A) then Result := 'DEVICE_UUID_KHR' else
      if self.val = UInt32($106B) then Result := 'DRIVER_UUID_KHR' else
      if self.val = UInt32($106C) then Result := 'DEVICE_LUID_VALID_KHR' else
      if self.val = UInt32($106D) then Result := 'DEVICE_LUID_KHR' else
      if self.val = UInt32($106E) then Result := 'DEVICE_NODE_MASK_KHR' else
      if self.val = UInt32($106F) then Result := 'DEVICE_OPENCL_C_FEATURES' else
      if self.val = UInt32($1070) then Result := 'DEVICE_DEVICE_ENQUEUE_CAPABILITIES' else
      if self.val = UInt32($1071) then Result := 'DEVICE_PIPE_SUPPORT' else
      if self.val = UInt32($1072) then Result := 'DEVICE_LATEST_CONFORMANCE_VERSION_PASSED' else
      if self.val = UInt32($1073) then Result := 'DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR' else
      if self.val = UInt32($1074) then Result := 'DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR' else
      if self.val = UInt32($1075) then Result := 'DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR' else
      if self.val = UInt32($12A9) then Result := 'DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR' else
      if self.val = UInt32($12AA) then Result := 'DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR' else
      if self.val = UInt32($2031) then Result := 'DEVICE_TERMINATE_CAPABILITY_KHR' else
      if self.val = UInt32($2035) then Result := 'DEVICE_MAX_NAMED_BARRIER_COUNT_KHR' else
      if self.val = UInt32($204C) then Result := 'DEVICE_SEMAPHORE_TYPES_KHR' else
      if self.val = UInt32($204D) then Result := 'DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt32($204E) then Result := 'DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt32($204F) then Result := 'DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt32($4000) then Result := 'DEVICE_COMPUTE_CAPABILITY_MAJOR_NV' else
      if self.val = UInt32($4001) then Result := 'DEVICE_COMPUTE_CAPABILITY_MINOR_NV' else
      if self.val = UInt32($4002) then Result := 'DEVICE_REGISTERS_PER_BLOCK_NV' else
      if self.val = UInt32($4003) then Result := 'DEVICE_WARP_SIZE_NV' else
      if self.val = UInt32($4004) then Result := 'DEVICE_GPU_OVERLAP_NV' else
      if self.val = UInt32($4005) then Result := 'DEVICE_KERNEL_EXEC_TIMEOUT_NV' else
      if self.val = UInt32($4006) then Result := 'DEVICE_INTEGRATED_MEMORY_NV' else
      if self.val = UInt32($4030) then Result := 'DEVICE_PREFERRED_WORK_GROUP_SIZE_AMD' else
      if self.val = UInt32($4031) then Result := 'DEVICE_MAX_WORK_GROUP_SIZE_AMD' else
      if self.val = UInt32($4033) then Result := 'DEVICE_PREFERRED_CONSTANT_BUFFER_SIZE_AMD' else
      if self.val = UInt32($4034) then Result := 'DEVICE_PCIE_ID_AMD' else
      if self.val = UInt32($4036) then Result := 'DEVICE_PROFILING_TIMER_OFFSET_AMD' else
      if self.val = UInt32($4037) then Result := 'DEVICE_TOPOLOGY_AMD' else
      if self.val = UInt32($4038) then Result := 'DEVICE_BOARD_NAME_AMD' else
      if self.val = UInt32($4039) then Result := 'DEVICE_GLOBAL_FREE_MEMORY_AMD' else
      if self.val = UInt32($4040) then Result := 'DEVICE_SIMD_PER_COMPUTE_UNIT_AMD' else
      if self.val = UInt32($4041) then Result := 'DEVICE_SIMD_WIDTH_AMD' else
      if self.val = UInt32($4042) then Result := 'DEVICE_SIMD_INSTRUCTION_WIDTH_AMD' else
      if self.val = UInt32($4043) then Result := 'DEVICE_WAVEFRONT_WIDTH_AMD' else
      if self.val = UInt32($4044) then Result := 'DEVICE_GLOBAL_MEM_CHANNELS_AMD' else
      if self.val = UInt32($4045) then Result := 'DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD' else
      if self.val = UInt32($4046) then Result := 'DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD' else
      if self.val = UInt32($4047) then Result := 'DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD' else
      if self.val = UInt32($4048) then Result := 'DEVICE_LOCAL_MEM_BANKS_AMD' else
      if self.val = UInt32($4049) then Result := 'DEVICE_THREAD_TRACE_SUPPORTED_AMD' else
      if self.val = UInt32($404A) then Result := 'DEVICE_GFXIP_MAJOR_AMD' else
      if self.val = UInt32($404B) then Result := 'DEVICE_GFXIP_MINOR_AMD' else
      if self.val = UInt32($404C) then Result := 'DEVICE_AVAILABLE_ASYNC_QUEUES_AMD' else
      if self.val = UInt32($4054) then Result := 'DEVICE_PARENT_DEVICE_EXT' else
      if self.val = UInt32($4055) then Result := 'DEVICE_PARTITION_TYPES_EXT' else
      if self.val = UInt32($4056) then Result := 'DEVICE_AFFINITY_DOMAINS_EXT' else
      if self.val = UInt32($4057) then Result := 'DEVICE_REFERENCE_COUNT_EXT' else
      if self.val = UInt32($4058) then Result := 'DEVICE_PARTITION_STYLE_EXT' else
      if self.val = UInt32($407E) then Result := 'DEVICE_ME_VERSION_INTEL' else
      if self.val = UInt32($40A0) then Result := 'DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM' else
      if self.val = UInt32($40A1) then Result := 'DEVICE_PAGE_SIZE_QCOM' else
      if self.val = UInt32($40B6) then Result := 'DEVICE_SVM_CAPABILITIES_ARM' else
      if self.val = UInt32($40BF) then Result := 'DEVICE_COMPUTE_UNITS_BITFIELD_ARM' else
      if self.val = UInt32($40E0) then Result := 'DEVICE_SPIR_VERSIONS' else
      if self.val = UInt32($4104) then Result := 'DEVICE_SIMULTANEOUS_INTEROPS_INTEL' else
      if self.val = UInt32($4105) then Result := 'DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL' else
      if self.val = UInt32($4108) then Result := 'DEVICE_SUB_GROUP_SIZES_INTEL' else
      if self.val = UInt32($410B) then Result := 'DEVICE_AVC_ME_VERSION_INTEL' else
      if self.val = UInt32($410C) then Result := 'DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL' else
      if self.val = UInt32($410D) then Result := 'DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL' else
      if self.val = UInt32($410F) then Result := 'DEVICE_PCI_BUS_INFO_KHR' else
      if self.val = UInt32($417E) then Result := 'DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL' else
      if self.val = UInt32($417F) then Result := 'DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL' else
      if self.val = UInt32($418B) then Result := 'DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL' else
      if self.val = UInt32($4190) then Result := 'DEVICE_HOST_MEM_CAPABILITIES_INTEL' else
      if self.val = UInt32($4191) then Result := 'DEVICE_DEVICE_MEM_CAPABILITIES_INTEL' else
      if self.val = UInt32($4192) then Result := 'DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL' else
      if self.val = UInt32($4193) then Result := 'DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL' else
      if self.val = UInt32($4194) then Result := 'DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL' else
      if self.val = UInt32($41E4) then Result := 'DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM' else
      if self.val = UInt32($41EB) then Result := 'DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM' else
      if self.val = UInt32($41EE) then Result := 'DEVICE_CONTROLLED_TERMINATION_CAPABILITIES_ARM' else
      if self.val = UInt32($4230) then Result := 'DEVICE_CXX_FOR_OPENCL_NUMERIC_VERSION_EXT' else
      if self.val = UInt32($4231) then Result := 'DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT' else
      if self.val = UInt32($4232) then Result := 'DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT' else
      if self.val = UInt32($4233) then Result := 'DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT' else
      if self.val = UInt32($4250) then Result := 'DEVICE_IP_VERSION_INTEL' else
      if self.val = UInt32($4251) then Result := 'DEVICE_ID_INTEL' else
      if self.val = UInt32($4252) then Result := 'DEVICE_NUM_SLICES_INTEL' else
      if self.val = UInt32($4253) then Result := 'DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL' else
      if self.val = UInt32($4254) then Result := 'DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL' else
      if self.val = UInt32($4255) then Result := 'DEVICE_NUM_THREADS_PER_EU_INTEL' else
      if self.val = UInt32($4256) then Result := 'DEVICE_FEATURE_CAPABILITIES_INTEL' else
        Result := $'DeviceInfo[{self.val}]';
    end;
    
  end;
  
  DeviceLocalMemType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property LOCAL:  DeviceLocalMemType read new DeviceLocalMemType($0001);
    public static property GLOBAL: DeviceLocalMemType read new DeviceLocalMemType($0002);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0001) then Result := 'LOCAL' else
      if self.val = UInt32($0002) then Result := 'GLOBAL' else
        Result := $'DeviceLocalMemType[{self.val}]';
    end;
    
  end;
  
  DeviceMemCacheType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property NONE:             DeviceMemCacheType read new DeviceMemCacheType($0000);
    public static property READ_ONLY_CACHE:  DeviceMemCacheType read new DeviceMemCacheType($0001);
    public static property READ_WRITE_CACHE: DeviceMemCacheType read new DeviceMemCacheType($0002);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'NONE' else
      if self.val = UInt32($0001) then Result := 'READ_ONLY_CACHE' else
      if self.val = UInt32($0002) then Result := 'READ_WRITE_CACHE' else
        Result := $'DeviceMemCacheType[{self.val}]';
    end;
    
  end;
  
  DevicePartitionProperty = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public constructor(val: Int32) := self.val := new IntPtr(val);
    
    public static property DEVICE_PARTITION_BY_COUNTS_LIST_END: DevicePartitionProperty read new DevicePartitionProperty($0000);
    public static property DEVICE_PARTITION_EQUALLY:            DevicePartitionProperty read new DevicePartitionProperty($1086);
    public static property DEVICE_PARTITION_BY_COUNTS:          DevicePartitionProperty read new DevicePartitionProperty($1087);
    public static property DEVICE_PARTITION_BY_AFFINITY_DOMAIN: DevicePartitionProperty read new DevicePartitionProperty($1088);
    
    public function ToString: string; override;
    begin
      if self.val = IntPtr($0000) then Result := 'DEVICE_PARTITION_BY_COUNTS_LIST_END' else
      if self.val = IntPtr($1086) then Result := 'DEVICE_PARTITION_EQUALLY' else
      if self.val = IntPtr($1087) then Result := 'DEVICE_PARTITION_BY_COUNTS' else
      if self.val = IntPtr($1088) then Result := 'DEVICE_PARTITION_BY_AFFINITY_DOMAIN' else
        Result := $'DevicePartitionProperty[{self.val}]';
    end;
    
  end;
  
  DevicePartitionPropertyExt = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property PARTITION_BY_COUNTS_LIST_END_EXT:        DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0000);
    public static property PROPERTIES_LIST_END_EXT:                 DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0000);
    public static property AFFINITY_DOMAIN_L1_CACHE_EXT:            DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0001);
    public static property PARTITION_BY_NAMES_LIST_END_EXT:         DevicePartitionPropertyExt read new DevicePartitionPropertyExt(-1);
    public static property AFFINITY_DOMAIN_L2_CACHE_EXT:            DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0002);
    public static property AFFINITY_DOMAIN_L3_CACHE_EXT:            DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0003);
    public static property AFFINITY_DOMAIN_L4_CACHE_EXT:            DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0004);
    public static property AFFINITY_DOMAIN_NUMA_EXT:                DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0010);
    public static property AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT:    DevicePartitionPropertyExt read new DevicePartitionPropertyExt($0100);
    public static property DEVICE_PARTITION_EQUALLY_EXT:            DevicePartitionPropertyExt read new DevicePartitionPropertyExt($4050);
    public static property DEVICE_PARTITION_BY_COUNTS_EXT:          DevicePartitionPropertyExt read new DevicePartitionPropertyExt($4051);
    public static property DEVICE_PARTITION_BY_NAMES_EXT:           DevicePartitionPropertyExt read new DevicePartitionPropertyExt($4052);
    public static property DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT: DevicePartitionPropertyExt read new DevicePartitionPropertyExt($4053);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0000) then Result := 'PARTITION_BY_COUNTS_LIST_END_EXT' else
      if self.val = UInt64($0000) then Result := 'PROPERTIES_LIST_END_EXT' else
      if self.val = UInt64($0001) then Result := 'AFFINITY_DOMAIN_L1_CACHE_EXT' else
      if self.val = UInt64(-1) then Result := 'PARTITION_BY_NAMES_LIST_END_EXT' else
      if self.val = UInt64($0002) then Result := 'AFFINITY_DOMAIN_L2_CACHE_EXT' else
      if self.val = UInt64($0003) then Result := 'AFFINITY_DOMAIN_L3_CACHE_EXT' else
      if self.val = UInt64($0004) then Result := 'AFFINITY_DOMAIN_L4_CACHE_EXT' else
      if self.val = UInt64($0010) then Result := 'AFFINITY_DOMAIN_NUMA_EXT' else
      if self.val = UInt64($0100) then Result := 'AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT' else
      if self.val = UInt64($4050) then Result := 'DEVICE_PARTITION_EQUALLY_EXT' else
      if self.val = UInt64($4051) then Result := 'DEVICE_PARTITION_BY_COUNTS_EXT' else
      if self.val = UInt64($4052) then Result := 'DEVICE_PARTITION_BY_NAMES_EXT' else
      if self.val = UInt64($4053) then Result := 'DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT' else
        Result := $'DevicePartitionPropertyExt[{self.val}]';
    end;
    
  end;
  
  DeviceSVMCapabilities = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property DEVICE_SVM_COARSE_GRAIN_BUFFER: DeviceSVMCapabilities read new DeviceSVMCapabilities($0001);
    public static property DEVICE_SVM_FINE_GRAIN_BUFFER:   DeviceSVMCapabilities read new DeviceSVMCapabilities($0002);
    public static property DEVICE_SVM_FINE_GRAIN_SYSTEM:   DeviceSVMCapabilities read new DeviceSVMCapabilities($0004);
    public static property DEVICE_SVM_ATOMICS:             DeviceSVMCapabilities read new DeviceSVMCapabilities($0008);
    
    public static function operator+(f1,f2: DeviceSVMCapabilities) := new DeviceSVMCapabilities(f1.val or f2.val);
    public static function operator or(f1,f2: DeviceSVMCapabilities) := f1+f2;
    
    public property HAS_FLAG_DEVICE_SVM_COARSE_GRAIN_BUFFER: boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_DEVICE_SVM_FINE_GRAIN_BUFFER:   boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_DEVICE_SVM_FINE_GRAIN_SYSTEM:   boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_DEVICE_SVM_ATOMICS:             boolean read self.val and $0008 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'DEVICE_SVM_COARSE_GRAIN_BUFFER+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'DEVICE_SVM_FINE_GRAIN_BUFFER+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'DEVICE_SVM_FINE_GRAIN_SYSTEM+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'DEVICE_SVM_ATOMICS+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'DeviceSVMCapabilities[{self.val}]';
    end;
    
  end;
  
  DeviceType = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property DEVICE_TYPE_DEFAULT:     DeviceType read new DeviceType($0001);
    public static property DEVICE_TYPE_CPU:         DeviceType read new DeviceType($0002);
    public static property DEVICE_TYPE_GPU:         DeviceType read new DeviceType($0004);
    public static property DEVICE_TYPE_ACCELERATOR: DeviceType read new DeviceType($0008);
    public static property DEVICE_TYPE_CUSTOM:      DeviceType read new DeviceType($0010);
    public static property DEVICE_TYPE_ALL:         DeviceType read new DeviceType($FFFFFFFF);
    
    public static function operator+(f1,f2: DeviceType) := new DeviceType(f1.val or f2.val);
    public static function operator or(f1,f2: DeviceType) := f1+f2;
    
    public property HAS_FLAG_DEVICE_TYPE_DEFAULT:     boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_DEVICE_TYPE_CPU:         boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_DEVICE_TYPE_GPU:         boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_DEVICE_TYPE_ACCELERATOR: boolean read self.val and $0008 <> 0;
    public property HAS_FLAG_DEVICE_TYPE_CUSTOM:      boolean read self.val and $0010 <> 0;
    public property HAS_FLAG_DEVICE_TYPE_ALL:         boolean read self.val and $FFFFFFFF <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'DEVICE_TYPE_DEFAULT+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'DEVICE_TYPE_CPU+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'DEVICE_TYPE_GPU+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'DEVICE_TYPE_ACCELERATOR+';
      if self.val and UInt64($0010) = UInt64($0010) then res += 'DEVICE_TYPE_CUSTOM+';
      if self.val and UInt64($FFFFFFFF) = UInt64($FFFFFFFF) then res += 'DEVICE_TYPE_ALL+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'DeviceType[{self.val}]';
    end;
    
  end;
  
  Dx9DeviceSetIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PREFERRED_DEVICES_FOR_DX9_INTEL: Dx9DeviceSetIntel read new Dx9DeviceSetIntel($4024);
    public static property ALL_DEVICES_FOR_DX9_INTEL:       Dx9DeviceSetIntel read new Dx9DeviceSetIntel($4025);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4024) then Result := 'PREFERRED_DEVICES_FOR_DX9_INTEL' else
      if self.val = UInt32($4025) then Result := 'ALL_DEVICES_FOR_DX9_INTEL' else
        Result := $'Dx9DeviceSetIntel[{self.val}]';
    end;
    
  end;
  
  Dx9DeviceSourceIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property D3D9_DEVICE_INTEL:   Dx9DeviceSourceIntel read new Dx9DeviceSourceIntel($4022);
    public static property D3D9EX_DEVICE_INTEL: Dx9DeviceSourceIntel read new Dx9DeviceSourceIntel($4070);
    public static property DXVA_DEVICE_INTEL:   Dx9DeviceSourceIntel read new Dx9DeviceSourceIntel($4071);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4022) then Result := 'D3D9_DEVICE_INTEL' else
      if self.val = UInt32($4070) then Result := 'D3D9EX_DEVICE_INTEL' else
      if self.val = UInt32($4071) then Result := 'DXVA_DEVICE_INTEL' else
        Result := $'Dx9DeviceSourceIntel[{self.val}]';
    end;
    
  end;
  
  EglImagePropertiesKhr = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public constructor(val: Int32) := self.val := new IntPtr(val);
    
    public static property EGL_YUV_PLANE_INTEL: EglImagePropertiesKhr read new EglImagePropertiesKhr($4107);
    
    public function ToString: string; override;
    begin
      if self.val = IntPtr($4107) then Result := 'EGL_YUV_PLANE_INTEL' else
        Result := $'EglImagePropertiesKhr[{self.val}]';
    end;
    
  end;
  
  ErrorCode = record
    public val: Int32;
    public constructor(val: Int32) := self.val := val;
    
    public static property SUCCESS:                                     ErrorCode read new ErrorCode($0000);
    public static property DEVICE_NOT_FOUND:                            ErrorCode read new ErrorCode(-1);
    public static property DEVICE_NOT_AVAILABLE:                        ErrorCode read new ErrorCode(-2);
    public static property COMPILER_NOT_AVAILABLE:                      ErrorCode read new ErrorCode(-3);
    public static property MEM_OBJECT_ALLOCATION_FAILURE:               ErrorCode read new ErrorCode(-4);
    public static property OUT_OF_RESOURCES:                            ErrorCode read new ErrorCode(-5);
    public static property OUT_OF_HOST_MEMORY:                          ErrorCode read new ErrorCode(-6);
    public static property PROFILING_INFO_NOT_AVAILABLE:                ErrorCode read new ErrorCode(-7);
    public static property MEM_COPY_OVERLAP:                            ErrorCode read new ErrorCode(-8);
    public static property IMAGE_FORMAT_MISMATCH:                       ErrorCode read new ErrorCode(-9);
    public static property IMAGE_FORMAT_NOT_SUPPORTED:                  ErrorCode read new ErrorCode(-10);
    public static property BUILD_PROGRAM_FAILURE:                       ErrorCode read new ErrorCode(-11);
    public static property MAP_FAILURE:                                 ErrorCode read new ErrorCode(-12);
    public static property MISALIGNED_SUB_BUFFER_OFFSET:                ErrorCode read new ErrorCode(-13);
    public static property EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST:   ErrorCode read new ErrorCode(-14);
    public static property COMPILE_PROGRAM_FAILURE:                     ErrorCode read new ErrorCode(-15);
    public static property LINKER_NOT_AVAILABLE:                        ErrorCode read new ErrorCode(-16);
    public static property LINK_PROGRAM_FAILURE:                        ErrorCode read new ErrorCode(-17);
    public static property DEVICE_PARTITION_FAILED:                     ErrorCode read new ErrorCode(-18);
    public static property KERNEL_ARG_INFO_NOT_AVAILABLE:               ErrorCode read new ErrorCode(-19);
    public static property INVALID_VALUE:                               ErrorCode read new ErrorCode(-30);
    public static property INVALID_DEVICE_TYPE:                         ErrorCode read new ErrorCode(-31);
    public static property INVALID_PLATFORM:                            ErrorCode read new ErrorCode(-32);
    public static property INVALID_DEVICE:                              ErrorCode read new ErrorCode(-33);
    public static property INVALID_CONTEXT:                             ErrorCode read new ErrorCode(-34);
    public static property INVALID_QUEUE_PROPERTIES:                    ErrorCode read new ErrorCode(-35);
    public static property INVALID_COMMAND_QUEUE:                       ErrorCode read new ErrorCode(-36);
    public static property INVALID_HOST_PTR:                            ErrorCode read new ErrorCode(-37);
    public static property INVALID_MEM_OBJECT:                          ErrorCode read new ErrorCode(-38);
    public static property INVALID_IMAGE_FORMAT_DESCRIPTOR:             ErrorCode read new ErrorCode(-39);
    public static property INVALID_IMAGE_SIZE:                          ErrorCode read new ErrorCode(-40);
    public static property INVALID_SAMPLER:                             ErrorCode read new ErrorCode(-41);
    public static property INVALID_BINARY:                              ErrorCode read new ErrorCode(-42);
    public static property INVALID_BUILD_OPTIONS:                       ErrorCode read new ErrorCode(-43);
    public static property INVALID_PROGRAM:                             ErrorCode read new ErrorCode(-44);
    public static property INVALID_PROGRAM_EXECUTABLE:                  ErrorCode read new ErrorCode(-45);
    public static property INVALID_KERNEL_NAME:                         ErrorCode read new ErrorCode(-46);
    public static property INVALID_KERNEL_DEFINITION:                   ErrorCode read new ErrorCode(-47);
    public static property INVALID_KERNEL:                              ErrorCode read new ErrorCode(-48);
    public static property INVALID_ARG_INDEX:                           ErrorCode read new ErrorCode(-49);
    public static property INVALID_ARG_VALUE:                           ErrorCode read new ErrorCode(-50);
    public static property INVALID_ARG_SIZE:                            ErrorCode read new ErrorCode(-51);
    public static property INVALID_KERNEL_ARGS:                         ErrorCode read new ErrorCode(-52);
    public static property INVALID_WORK_DIMENSION:                      ErrorCode read new ErrorCode(-53);
    public static property INVALID_WORK_GROUP_SIZE:                     ErrorCode read new ErrorCode(-54);
    public static property INVALID_WORK_ITEM_SIZE:                      ErrorCode read new ErrorCode(-55);
    public static property INVALID_GLOBAL_OFFSET:                       ErrorCode read new ErrorCode(-56);
    public static property INVALID_EVENT_WAIT_LIST:                     ErrorCode read new ErrorCode(-57);
    public static property INVALID_EVENT:                               ErrorCode read new ErrorCode(-58);
    public static property INVALID_OPERATION:                           ErrorCode read new ErrorCode(-59);
    public static property INVALID_GL_OBJECT:                           ErrorCode read new ErrorCode(-60);
    public static property INVALID_BUFFER_SIZE:                         ErrorCode read new ErrorCode(-61);
    public static property INVALID_MIP_LEVEL:                           ErrorCode read new ErrorCode(-62);
    public static property INVALID_GLOBAL_WORK_SIZE:                    ErrorCode read new ErrorCode(-63);
    public static property INVALID_PROPERTY:                            ErrorCode read new ErrorCode(-64);
    public static property INVALID_IMAGE_DESCRIPTOR:                    ErrorCode read new ErrorCode(-65);
    public static property INVALID_COMPILER_OPTIONS:                    ErrorCode read new ErrorCode(-66);
    public static property INVALID_LINKER_OPTIONS:                      ErrorCode read new ErrorCode(-67);
    public static property INVALID_DEVICE_PARTITION_COUNT:              ErrorCode read new ErrorCode(-68);
    public static property INVALID_PIPE_SIZE:                           ErrorCode read new ErrorCode(-69);
    public static property INVALID_DEVICE_QUEUE:                        ErrorCode read new ErrorCode(-70);
    public static property INVALID_SPEC_ID:                             ErrorCode read new ErrorCode(-71);
    public static property MAX_SIZE_RESTRICTION_EXCEEDED:               ErrorCode read new ErrorCode(-72);
    public static property INVALID_GL_SHAREGROUP_REFERENCE_KHR:         ErrorCode read new ErrorCode(-1000);
    public static property PLATFORM_NOT_FOUND_KHR:                      ErrorCode read new ErrorCode(-1001);
    public static property INVALID_D3D10_DEVICE_KHR:                    ErrorCode read new ErrorCode(-1002);
    public static property INVALID_D3D10_RESOURCE_KHR:                  ErrorCode read new ErrorCode(-1003);
    public static property D3D10_RESOURCE_ALREADY_ACQUIRED_KHR:         ErrorCode read new ErrorCode(-1004);
    public static property D3D10_RESOURCE_NOT_ACQUIRED_KHR:             ErrorCode read new ErrorCode(-1005);
    public static property INVALID_D3D11_DEVICE_KHR:                    ErrorCode read new ErrorCode(-1006);
    public static property INVALID_D3D11_RESOURCE_KHR:                  ErrorCode read new ErrorCode(-1007);
    public static property D3D11_RESOURCE_ALREADY_ACQUIRED_KHR:         ErrorCode read new ErrorCode(-1008);
    public static property D3D11_RESOURCE_NOT_ACQUIRED_KHR:             ErrorCode read new ErrorCode(-1009);
    public static property INVALID_DX9_DEVICE_INTEL:                    ErrorCode read new ErrorCode(-1010);
    public static property INVALID_DX9_MEDIA_ADAPTER_KHR:               ErrorCode read new ErrorCode(-1010);
    public static property INVALID_DX9_MEDIA_SURFACE_KHR:               ErrorCode read new ErrorCode(-1011);
    public static property INVALID_DX9_RESOURCE_INTEL:                  ErrorCode read new ErrorCode(-1011);
    public static property DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR:      ErrorCode read new ErrorCode(-1012);
    public static property DX9_RESOURCE_ALREADY_ACQUIRED_INTEL:         ErrorCode read new ErrorCode(-1012);
    public static property DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR:          ErrorCode read new ErrorCode(-1013);
    public static property DX9_RESOURCE_NOT_ACQUIRED_INTEL:             ErrorCode read new ErrorCode(-1013);
    public static property DEVICE_PARTITION_FAILED_EXT:                 ErrorCode read new ErrorCode(-1057);
    public static property INVALID_PARTITION_COUNT_EXT:                 ErrorCode read new ErrorCode(-1058);
    public static property INVALID_PARTITION_NAME_EXT:                  ErrorCode read new ErrorCode(-1059);
    public static property EGL_RESOURCE_NOT_ACQUIRED_KHR:               ErrorCode read new ErrorCode(-1092);
    public static property INVALID_EGL_OBJECT_KHR:                      ErrorCode read new ErrorCode(-1093);
    public static property INVALID_ACCELERATOR_INTEL:                   ErrorCode read new ErrorCode(-1094);
    public static property INVALID_ACCELERATOR_TYPE_INTEL:              ErrorCode read new ErrorCode(-1095);
    public static property INVALID_ACCELERATOR_DESCRIPTOR_INTEL:        ErrorCode read new ErrorCode(-1096);
    public static property ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL:        ErrorCode read new ErrorCode(-1097);
    public static property INVALID_VA_API_MEDIA_ADAPTER_INTEL:          ErrorCode read new ErrorCode(-1098);
    public static property INVALID_VA_API_MEDIA_SURFACE_INTEL:          ErrorCode read new ErrorCode(-1099);
    public static property VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL: ErrorCode read new ErrorCode(-1100);
    public static property VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL:     ErrorCode read new ErrorCode(-1101);
    public static property PIPE_FULL_INTEL:                             ErrorCode read new ErrorCode(-1106);
    public static property PIPE_EMPTY_INTEL:                            ErrorCode read new ErrorCode(-1107);
    public static property COMMAND_TERMINATED_ITSELF_WITH_FAILURE_ARM:  ErrorCode read new ErrorCode(-1108);
    public static property CONTEXT_TERMINATED_KHR:                      ErrorCode read new ErrorCode(-1121);
    public static property ERROR_RESERVED0_IMG:                         ErrorCode read new ErrorCode(-1122);
    public static property ERROR_RESERVED1_IMG:                         ErrorCode read new ErrorCode(-1123);
    public static property ERROR_RESERVED2_IMG:                         ErrorCode read new ErrorCode(-1124);
    public static property ERROR_RESERVED3_IMG:                         ErrorCode read new ErrorCode(-1125);
    public static property INVALID_COMMAND_BUFFER_KHR:                  ErrorCode read new ErrorCode(-1138);
    public static property INVALID_SYNC_POINT_WAIT_LIST_KHR:            ErrorCode read new ErrorCode(-1139);
    public static property INCOMPATIBLE_COMMAND_QUEUE_KHR:              ErrorCode read new ErrorCode(-1140);
    public static property INVALID_SEMAPHORE_KHR:                       ErrorCode read new ErrorCode(-1142);
    public static property NV_KERNEL_ILLEGAL_BUFFER_READ_WRITE:         ErrorCode read new ErrorCode(-9999);
    
    public function ToString: string; override;
    begin
      if self.val = Int32($0000) then Result := 'SUCCESS' else
      if self.val = Int32(-1) then Result := 'DEVICE_NOT_FOUND' else
      if self.val = Int32(-2) then Result := 'DEVICE_NOT_AVAILABLE' else
      if self.val = Int32(-3) then Result := 'COMPILER_NOT_AVAILABLE' else
      if self.val = Int32(-4) then Result := 'MEM_OBJECT_ALLOCATION_FAILURE' else
      if self.val = Int32(-5) then Result := 'OUT_OF_RESOURCES' else
      if self.val = Int32(-6) then Result := 'OUT_OF_HOST_MEMORY' else
      if self.val = Int32(-7) then Result := 'PROFILING_INFO_NOT_AVAILABLE' else
      if self.val = Int32(-8) then Result := 'MEM_COPY_OVERLAP' else
      if self.val = Int32(-9) then Result := 'IMAGE_FORMAT_MISMATCH' else
      if self.val = Int32(-10) then Result := 'IMAGE_FORMAT_NOT_SUPPORTED' else
      if self.val = Int32(-11) then Result := 'BUILD_PROGRAM_FAILURE' else
      if self.val = Int32(-12) then Result := 'MAP_FAILURE' else
      if self.val = Int32(-13) then Result := 'MISALIGNED_SUB_BUFFER_OFFSET' else
      if self.val = Int32(-14) then Result := 'EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST' else
      if self.val = Int32(-15) then Result := 'COMPILE_PROGRAM_FAILURE' else
      if self.val = Int32(-16) then Result := 'LINKER_NOT_AVAILABLE' else
      if self.val = Int32(-17) then Result := 'LINK_PROGRAM_FAILURE' else
      if self.val = Int32(-18) then Result := 'DEVICE_PARTITION_FAILED' else
      if self.val = Int32(-19) then Result := 'KERNEL_ARG_INFO_NOT_AVAILABLE' else
      if self.val = Int32(-30) then Result := 'INVALID_VALUE' else
      if self.val = Int32(-31) then Result := 'INVALID_DEVICE_TYPE' else
      if self.val = Int32(-32) then Result := 'INVALID_PLATFORM' else
      if self.val = Int32(-33) then Result := 'INVALID_DEVICE' else
      if self.val = Int32(-34) then Result := 'INVALID_CONTEXT' else
      if self.val = Int32(-35) then Result := 'INVALID_QUEUE_PROPERTIES' else
      if self.val = Int32(-36) then Result := 'INVALID_COMMAND_QUEUE' else
      if self.val = Int32(-37) then Result := 'INVALID_HOST_PTR' else
      if self.val = Int32(-38) then Result := 'INVALID_MEM_OBJECT' else
      if self.val = Int32(-39) then Result := 'INVALID_IMAGE_FORMAT_DESCRIPTOR' else
      if self.val = Int32(-40) then Result := 'INVALID_IMAGE_SIZE' else
      if self.val = Int32(-41) then Result := 'INVALID_SAMPLER' else
      if self.val = Int32(-42) then Result := 'INVALID_BINARY' else
      if self.val = Int32(-43) then Result := 'INVALID_BUILD_OPTIONS' else
      if self.val = Int32(-44) then Result := 'INVALID_PROGRAM' else
      if self.val = Int32(-45) then Result := 'INVALID_PROGRAM_EXECUTABLE' else
      if self.val = Int32(-46) then Result := 'INVALID_KERNEL_NAME' else
      if self.val = Int32(-47) then Result := 'INVALID_KERNEL_DEFINITION' else
      if self.val = Int32(-48) then Result := 'INVALID_KERNEL' else
      if self.val = Int32(-49) then Result := 'INVALID_ARG_INDEX' else
      if self.val = Int32(-50) then Result := 'INVALID_ARG_VALUE' else
      if self.val = Int32(-51) then Result := 'INVALID_ARG_SIZE' else
      if self.val = Int32(-52) then Result := 'INVALID_KERNEL_ARGS' else
      if self.val = Int32(-53) then Result := 'INVALID_WORK_DIMENSION' else
      if self.val = Int32(-54) then Result := 'INVALID_WORK_GROUP_SIZE' else
      if self.val = Int32(-55) then Result := 'INVALID_WORK_ITEM_SIZE' else
      if self.val = Int32(-56) then Result := 'INVALID_GLOBAL_OFFSET' else
      if self.val = Int32(-57) then Result := 'INVALID_EVENT_WAIT_LIST' else
      if self.val = Int32(-58) then Result := 'INVALID_EVENT' else
      if self.val = Int32(-59) then Result := 'INVALID_OPERATION' else
      if self.val = Int32(-60) then Result := 'INVALID_GL_OBJECT' else
      if self.val = Int32(-61) then Result := 'INVALID_BUFFER_SIZE' else
      if self.val = Int32(-62) then Result := 'INVALID_MIP_LEVEL' else
      if self.val = Int32(-63) then Result := 'INVALID_GLOBAL_WORK_SIZE' else
      if self.val = Int32(-64) then Result := 'INVALID_PROPERTY' else
      if self.val = Int32(-65) then Result := 'INVALID_IMAGE_DESCRIPTOR' else
      if self.val = Int32(-66) then Result := 'INVALID_COMPILER_OPTIONS' else
      if self.val = Int32(-67) then Result := 'INVALID_LINKER_OPTIONS' else
      if self.val = Int32(-68) then Result := 'INVALID_DEVICE_PARTITION_COUNT' else
      if self.val = Int32(-69) then Result := 'INVALID_PIPE_SIZE' else
      if self.val = Int32(-70) then Result := 'INVALID_DEVICE_QUEUE' else
      if self.val = Int32(-71) then Result := 'INVALID_SPEC_ID' else
      if self.val = Int32(-72) then Result := 'MAX_SIZE_RESTRICTION_EXCEEDED' else
      if self.val = Int32(-1000) then Result := 'INVALID_GL_SHAREGROUP_REFERENCE_KHR' else
      if self.val = Int32(-1001) then Result := 'PLATFORM_NOT_FOUND_KHR' else
      if self.val = Int32(-1002) then Result := 'INVALID_D3D10_DEVICE_KHR' else
      if self.val = Int32(-1003) then Result := 'INVALID_D3D10_RESOURCE_KHR' else
      if self.val = Int32(-1004) then Result := 'D3D10_RESOURCE_ALREADY_ACQUIRED_KHR' else
      if self.val = Int32(-1005) then Result := 'D3D10_RESOURCE_NOT_ACQUIRED_KHR' else
      if self.val = Int32(-1006) then Result := 'INVALID_D3D11_DEVICE_KHR' else
      if self.val = Int32(-1007) then Result := 'INVALID_D3D11_RESOURCE_KHR' else
      if self.val = Int32(-1008) then Result := 'D3D11_RESOURCE_ALREADY_ACQUIRED_KHR' else
      if self.val = Int32(-1009) then Result := 'D3D11_RESOURCE_NOT_ACQUIRED_KHR' else
      if self.val = Int32(-1010) then Result := 'INVALID_DX9_DEVICE_INTEL' else
      if self.val = Int32(-1010) then Result := 'INVALID_DX9_MEDIA_ADAPTER_KHR' else
      if self.val = Int32(-1011) then Result := 'INVALID_DX9_MEDIA_SURFACE_KHR' else
      if self.val = Int32(-1011) then Result := 'INVALID_DX9_RESOURCE_INTEL' else
      if self.val = Int32(-1012) then Result := 'DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR' else
      if self.val = Int32(-1012) then Result := 'DX9_RESOURCE_ALREADY_ACQUIRED_INTEL' else
      if self.val = Int32(-1013) then Result := 'DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR' else
      if self.val = Int32(-1013) then Result := 'DX9_RESOURCE_NOT_ACQUIRED_INTEL' else
      if self.val = Int32(-1057) then Result := 'DEVICE_PARTITION_FAILED_EXT' else
      if self.val = Int32(-1058) then Result := 'INVALID_PARTITION_COUNT_EXT' else
      if self.val = Int32(-1059) then Result := 'INVALID_PARTITION_NAME_EXT' else
      if self.val = Int32(-1092) then Result := 'EGL_RESOURCE_NOT_ACQUIRED_KHR' else
      if self.val = Int32(-1093) then Result := 'INVALID_EGL_OBJECT_KHR' else
      if self.val = Int32(-1094) then Result := 'INVALID_ACCELERATOR_INTEL' else
      if self.val = Int32(-1095) then Result := 'INVALID_ACCELERATOR_TYPE_INTEL' else
      if self.val = Int32(-1096) then Result := 'INVALID_ACCELERATOR_DESCRIPTOR_INTEL' else
      if self.val = Int32(-1097) then Result := 'ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL' else
      if self.val = Int32(-1098) then Result := 'INVALID_VA_API_MEDIA_ADAPTER_INTEL' else
      if self.val = Int32(-1099) then Result := 'INVALID_VA_API_MEDIA_SURFACE_INTEL' else
      if self.val = Int32(-1100) then Result := 'VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL' else
      if self.val = Int32(-1101) then Result := 'VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL' else
      if self.val = Int32(-1106) then Result := 'PIPE_FULL_INTEL' else
      if self.val = Int32(-1107) then Result := 'PIPE_EMPTY_INTEL' else
      if self.val = Int32(-1108) then Result := 'COMMAND_TERMINATED_ITSELF_WITH_FAILURE_ARM' else
      if self.val = Int32(-1121) then Result := 'CONTEXT_TERMINATED_KHR' else
      if self.val = Int32(-1122) then Result := 'ERROR_RESERVED0_IMG' else
      if self.val = Int32(-1123) then Result := 'ERROR_RESERVED1_IMG' else
      if self.val = Int32(-1124) then Result := 'ERROR_RESERVED2_IMG' else
      if self.val = Int32(-1125) then Result := 'ERROR_RESERVED3_IMG' else
      if self.val = Int32(-1138) then Result := 'INVALID_COMMAND_BUFFER_KHR' else
      if self.val = Int32(-1139) then Result := 'INVALID_SYNC_POINT_WAIT_LIST_KHR' else
      if self.val = Int32(-1140) then Result := 'INCOMPATIBLE_COMMAND_QUEUE_KHR' else
      if self.val = Int32(-1142) then Result := 'INVALID_SEMAPHORE_KHR' else
      if self.val = Int32(-9999) then Result := 'NV_KERNEL_ILLEGAL_BUFFER_READ_WRITE' else
        Result := $'ErrorCode[{self.val}]';
    end;
    
    public function IS_ERROR := val<>0;
    
    public procedure RaiseIfError;
    
    public static function operator explicit(st: CommandExecutionStatus): ErrorCode := new ErrorCode(st.val);
    public static function operator explicit(ec: ErrorCode): CommandExecutionStatus := new CommandExecutionStatus(ec.val);
    
  end;
  
  EventInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property EVENT_COMMAND_QUEUE:                  EventInfo read new EventInfo($11D0);
    public static property EVENT_COMMAND_TYPE:                   EventInfo read new EventInfo($11D1);
    public static property EVENT_REFERENCE_COUNT:                EventInfo read new EventInfo($11D2);
    public static property EVENT_COMMAND_EXECUTION_STATUS:       EventInfo read new EventInfo($11D3);
    public static property EVENT_CONTEXT:                        EventInfo read new EventInfo($11D4);
    public static property EVENT_COMMAND_TERMINATION_REASON_ARM: EventInfo read new EventInfo($41ED);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11D0) then Result := 'EVENT_COMMAND_QUEUE' else
      if self.val = UInt32($11D1) then Result := 'EVENT_COMMAND_TYPE' else
      if self.val = UInt32($11D2) then Result := 'EVENT_REFERENCE_COUNT' else
      if self.val = UInt32($11D3) then Result := 'EVENT_COMMAND_EXECUTION_STATUS' else
      if self.val = UInt32($11D4) then Result := 'EVENT_CONTEXT' else
      if self.val = UInt32($41ED) then Result := 'EVENT_COMMAND_TERMINATION_REASON_ARM' else
        Result := $'EventInfo[{self.val}]';
    end;
    
  end;
  
  ExternalSemaphoreHandleTypeKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property SEMAPHORE_HANDLE_OPAQUE_FD_KHR:        ExternalSemaphoreHandleTypeKhr read new ExternalSemaphoreHandleTypeKhr($2055);
    public static property SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR:     ExternalSemaphoreHandleTypeKhr read new ExternalSemaphoreHandleTypeKhr($2056);
    public static property SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR: ExternalSemaphoreHandleTypeKhr read new ExternalSemaphoreHandleTypeKhr($2057);
    public static property SEMAPHORE_HANDLE_SYNC_FD_KHR:          ExternalSemaphoreHandleTypeKhr read new ExternalSemaphoreHandleTypeKhr($2058);
    public static property SEMAPHORE_HANDLE_D3D12_FENCE_KHR:      ExternalSemaphoreHandleTypeKhr read new ExternalSemaphoreHandleTypeKhr($2059);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($2055) then Result := 'SEMAPHORE_HANDLE_OPAQUE_FD_KHR' else
      if self.val = UInt32($2056) then Result := 'SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR' else
      if self.val = UInt32($2057) then Result := 'SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR' else
      if self.val = UInt32($2058) then Result := 'SEMAPHORE_HANDLE_SYNC_FD_KHR' else
      if self.val = UInt32($2059) then Result := 'SEMAPHORE_HANDLE_D3D12_FENCE_KHR' else
        Result := $'ExternalSemaphoreHandleTypeKhr[{self.val}]';
    end;
    
  end;
  
  FilterMode = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property FILTER_NEAREST: FilterMode read new FilterMode($1140);
    public static property FILTER_LINEAR:  FilterMode read new FilterMode($1141);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1140) then Result := 'FILTER_NEAREST' else
      if self.val = UInt32($1141) then Result := 'FILTER_LINEAR' else
        Result := $'FilterMode[{self.val}]';
    end;
    
  end;
  
  GlContextInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property CURRENT_DEVICE_FOR_GL_CONTEXT_KHR: GlContextInfo read new GlContextInfo($2006);
    public static property DEVICES_FOR_GL_CONTEXT_KHR:        GlContextInfo read new GlContextInfo($2007);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($2006) then Result := 'CURRENT_DEVICE_FOR_GL_CONTEXT_KHR' else
      if self.val = UInt32($2007) then Result := 'DEVICES_FOR_GL_CONTEXT_KHR' else
        Result := $'GlContextInfo[{self.val}]';
    end;
    
  end;
  
  GlObjectType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property GL_OBJECT_BUFFER:          GlObjectType read new GlObjectType($2000);
    public static property GL_OBJECT_TEXTURE2D:       GlObjectType read new GlObjectType($2001);
    public static property GL_OBJECT_TEXTURE3D:       GlObjectType read new GlObjectType($2002);
    public static property GL_OBJECT_RENDERBUFFER:    GlObjectType read new GlObjectType($2003);
    public static property GL_OBJECT_TEXTURE2D_ARRAY: GlObjectType read new GlObjectType($200E);
    public static property GL_OBJECT_TEXTURE1D:       GlObjectType read new GlObjectType($200F);
    public static property GL_OBJECT_TEXTURE1D_ARRAY: GlObjectType read new GlObjectType($2010);
    public static property GL_OBJECT_TEXTURE_BUFFER:  GlObjectType read new GlObjectType($2011);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($2000) then Result := 'GL_OBJECT_BUFFER' else
      if self.val = UInt32($2001) then Result := 'GL_OBJECT_TEXTURE2D' else
      if self.val = UInt32($2002) then Result := 'GL_OBJECT_TEXTURE3D' else
      if self.val = UInt32($2003) then Result := 'GL_OBJECT_RENDERBUFFER' else
      if self.val = UInt32($200E) then Result := 'GL_OBJECT_TEXTURE2D_ARRAY' else
      if self.val = UInt32($200F) then Result := 'GL_OBJECT_TEXTURE1D' else
      if self.val = UInt32($2010) then Result := 'GL_OBJECT_TEXTURE1D_ARRAY' else
      if self.val = UInt32($2011) then Result := 'GL_OBJECT_TEXTURE_BUFFER' else
        Result := $'GlObjectType[{self.val}]';
    end;
    
  end;
  
  GlTextureInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property GL_TEXTURE_TARGET: GlTextureInfo read new GlTextureInfo($2004);
    public static property GL_MIPMAP_LEVEL:   GlTextureInfo read new GlTextureInfo($2005);
    public static property GL_NUM_SAMPLES:    GlTextureInfo read new GlTextureInfo($2012);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($2004) then Result := 'GL_TEXTURE_TARGET' else
      if self.val = UInt32($2005) then Result := 'GL_MIPMAP_LEVEL' else
      if self.val = UInt32($2012) then Result := 'GL_NUM_SAMPLES' else
        Result := $'GlTextureInfo[{self.val}]';
    end;
    
  end;
  
  ImageInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property IMAGE_FORMAT:                ImageInfo read new ImageInfo($1110);
    public static property IMAGE_ELEMENT_SIZE:          ImageInfo read new ImageInfo($1111);
    public static property IMAGE_ROW_PITCH:             ImageInfo read new ImageInfo($1112);
    public static property IMAGE_SLICE_PITCH:           ImageInfo read new ImageInfo($1113);
    public static property IMAGE_WIDTH:                 ImageInfo read new ImageInfo($1114);
    public static property IMAGE_HEIGHT:                ImageInfo read new ImageInfo($1115);
    public static property IMAGE_DEPTH:                 ImageInfo read new ImageInfo($1116);
    public static property IMAGE_ARRAY_SIZE:            ImageInfo read new ImageInfo($1117);
    public static property IMAGE_BUFFER:                ImageInfo read new ImageInfo($1118);
    public static property IMAGE_NUM_MIP_LEVELS:        ImageInfo read new ImageInfo($1119);
    public static property IMAGE_NUM_SAMPLES:           ImageInfo read new ImageInfo($111A);
    public static property IMAGE_DX9_MEDIA_PLANE_KHR:   ImageInfo read new ImageInfo($202A);
    public static property IMAGE_D3D10_SUBRESOURCE_KHR: ImageInfo read new ImageInfo($4016);
    public static property IMAGE_D3D11_SUBRESOURCE_KHR: ImageInfo read new ImageInfo($401F);
    public static property IMAGE_DX9_PLANE_INTEL:       ImageInfo read new ImageInfo($4075);
    public static property IMAGE_VA_API_PLANE_INTEL:    ImageInfo read new ImageInfo($4099);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1110) then Result := 'IMAGE_FORMAT' else
      if self.val = UInt32($1111) then Result := 'IMAGE_ELEMENT_SIZE' else
      if self.val = UInt32($1112) then Result := 'IMAGE_ROW_PITCH' else
      if self.val = UInt32($1113) then Result := 'IMAGE_SLICE_PITCH' else
      if self.val = UInt32($1114) then Result := 'IMAGE_WIDTH' else
      if self.val = UInt32($1115) then Result := 'IMAGE_HEIGHT' else
      if self.val = UInt32($1116) then Result := 'IMAGE_DEPTH' else
      if self.val = UInt32($1117) then Result := 'IMAGE_ARRAY_SIZE' else
      if self.val = UInt32($1118) then Result := 'IMAGE_BUFFER' else
      if self.val = UInt32($1119) then Result := 'IMAGE_NUM_MIP_LEVELS' else
      if self.val = UInt32($111A) then Result := 'IMAGE_NUM_SAMPLES' else
      if self.val = UInt32($202A) then Result := 'IMAGE_DX9_MEDIA_PLANE_KHR' else
      if self.val = UInt32($4016) then Result := 'IMAGE_D3D10_SUBRESOURCE_KHR' else
      if self.val = UInt32($401F) then Result := 'IMAGE_D3D11_SUBRESOURCE_KHR' else
      if self.val = UInt32($4075) then Result := 'IMAGE_DX9_PLANE_INTEL' else
      if self.val = UInt32($4099) then Result := 'IMAGE_VA_API_PLANE_INTEL' else
        Result := $'ImageInfo[{self.val}]';
    end;
    
  end;
  
  ImagePitchInfoQcom = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property IMAGE_ROW_ALIGNMENT_QCOM:   ImagePitchInfoQcom read new ImagePitchInfoQcom($40A2);
    public static property IMAGE_SLICE_ALIGNMENT_QCOM: ImagePitchInfoQcom read new ImagePitchInfoQcom($40A3);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($40A2) then Result := 'IMAGE_ROW_ALIGNMENT_QCOM' else
      if self.val = UInt32($40A3) then Result := 'IMAGE_SLICE_ALIGNMENT_QCOM' else
        Result := $'ImagePitchInfoQcom[{self.val}]';
    end;
    
  end;
  
  ImportPropertiesArm = record
    public val: IntPtr;
    public constructor(val: IntPtr) := self.val := val;
    public constructor(val: Int32) := self.val := new IntPtr(val);
    
    public static property IMPORT_MEMORY_WHOLE_ALLOCATION_ARM:             ImportPropertiesArm read new ImportPropertiesArm(-1);
    public static property IMPORT_TYPE_ARM:                                ImportPropertiesArm read new ImportPropertiesArm($40B2);
    public static property IMPORT_TYPE_HOST_ARM:                           ImportPropertiesArm read new ImportPropertiesArm($40B3);
    public static property IMPORT_TYPE_DMA_BUF_ARM:                        ImportPropertiesArm read new ImportPropertiesArm($40B4);
    public static property IMPORT_TYPE_PROTECTED_ARM:                      ImportPropertiesArm read new ImportPropertiesArm($40B5);
    public static property IMPORT_TYPE_ANDROID_HARDWARE_BUFFER_ARM:        ImportPropertiesArm read new ImportPropertiesArm($41E2);
    public static property IMPORT_DMA_BUF_DATA_CONSISTENCY_WITH_HOST_ARM:  ImportPropertiesArm read new ImportPropertiesArm($41E3);
    public static property IMPORT_ANDROID_HARDWARE_BUFFER_PLANE_INDEX_ARM: ImportPropertiesArm read new ImportPropertiesArm($41EF);
    public static property IMPORT_ANDROID_HARDWARE_BUFFER_LAYER_INDEX_ARM: ImportPropertiesArm read new ImportPropertiesArm($41F0);
    
    public function ToString: string; override;
    begin
      if self.val = IntPtr(-1) then Result := 'IMPORT_MEMORY_WHOLE_ALLOCATION_ARM' else
      if self.val = IntPtr($40B2) then Result := 'IMPORT_TYPE_ARM' else
      if self.val = IntPtr($40B3) then Result := 'IMPORT_TYPE_HOST_ARM' else
      if self.val = IntPtr($40B4) then Result := 'IMPORT_TYPE_DMA_BUF_ARM' else
      if self.val = IntPtr($40B5) then Result := 'IMPORT_TYPE_PROTECTED_ARM' else
      if self.val = IntPtr($41E2) then Result := 'IMPORT_TYPE_ANDROID_HARDWARE_BUFFER_ARM' else
      if self.val = IntPtr($41E3) then Result := 'IMPORT_DMA_BUF_DATA_CONSISTENCY_WITH_HOST_ARM' else
      if self.val = IntPtr($41EF) then Result := 'IMPORT_ANDROID_HARDWARE_BUFFER_PLANE_INDEX_ARM' else
      if self.val = IntPtr($41F0) then Result := 'IMPORT_ANDROID_HARDWARE_BUFFER_LAYER_INDEX_ARM' else
        Result := $'ImportPropertiesArm[{self.val}]';
    end;
    
  end;
  
  KernelArgAccessQualifier = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_ARG_ACCESS_READ_ONLY:  KernelArgAccessQualifier read new KernelArgAccessQualifier($11A0);
    public static property KERNEL_ARG_ACCESS_WRITE_ONLY: KernelArgAccessQualifier read new KernelArgAccessQualifier($11A1);
    public static property KERNEL_ARG_ACCESS_READ_WRITE: KernelArgAccessQualifier read new KernelArgAccessQualifier($11A2);
    public static property KERNEL_ARG_ACCESS_NONE:       KernelArgAccessQualifier read new KernelArgAccessQualifier($11A3);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11A0) then Result := 'KERNEL_ARG_ACCESS_READ_ONLY' else
      if self.val = UInt32($11A1) then Result := 'KERNEL_ARG_ACCESS_WRITE_ONLY' else
      if self.val = UInt32($11A2) then Result := 'KERNEL_ARG_ACCESS_READ_WRITE' else
      if self.val = UInt32($11A3) then Result := 'KERNEL_ARG_ACCESS_NONE' else
        Result := $'KernelArgAccessQualifier[{self.val}]';
    end;
    
  end;
  
  KernelArgAddressQualifier = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_ARG_ADDRESS_GLOBAL:   KernelArgAddressQualifier read new KernelArgAddressQualifier($119B);
    public static property KERNEL_ARG_ADDRESS_LOCAL:    KernelArgAddressQualifier read new KernelArgAddressQualifier($119C);
    public static property KERNEL_ARG_ADDRESS_CONSTANT: KernelArgAddressQualifier read new KernelArgAddressQualifier($119D);
    public static property KERNEL_ARG_ADDRESS_PRIVATE:  KernelArgAddressQualifier read new KernelArgAddressQualifier($119E);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($119B) then Result := 'KERNEL_ARG_ADDRESS_GLOBAL' else
      if self.val = UInt32($119C) then Result := 'KERNEL_ARG_ADDRESS_LOCAL' else
      if self.val = UInt32($119D) then Result := 'KERNEL_ARG_ADDRESS_CONSTANT' else
      if self.val = UInt32($119E) then Result := 'KERNEL_ARG_ADDRESS_PRIVATE' else
        Result := $'KernelArgAddressQualifier[{self.val}]';
    end;
    
  end;
  
  KernelArgInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_ARG_ADDRESS_QUALIFIER: KernelArgInfo read new KernelArgInfo($1196);
    public static property KERNEL_ARG_ACCESS_QUALIFIER:  KernelArgInfo read new KernelArgInfo($1197);
    public static property KERNEL_ARG_TYPE_NAME:         KernelArgInfo read new KernelArgInfo($1198);
    public static property KERNEL_ARG_TYPE_QUALIFIER:    KernelArgInfo read new KernelArgInfo($1199);
    public static property KERNEL_ARG_NAME:              KernelArgInfo read new KernelArgInfo($119A);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1196) then Result := 'KERNEL_ARG_ADDRESS_QUALIFIER' else
      if self.val = UInt32($1197) then Result := 'KERNEL_ARG_ACCESS_QUALIFIER' else
      if self.val = UInt32($1198) then Result := 'KERNEL_ARG_TYPE_NAME' else
      if self.val = UInt32($1199) then Result := 'KERNEL_ARG_TYPE_QUALIFIER' else
      if self.val = UInt32($119A) then Result := 'KERNEL_ARG_NAME' else
        Result := $'KernelArgInfo[{self.val}]';
    end;
    
  end;
  
  KernelArgTypeQualifier = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property KERNEL_ARG_TYPE_NONE:     KernelArgTypeQualifier read new KernelArgTypeQualifier($0000);
    public static property KERNEL_ARG_TYPE_CONST:    KernelArgTypeQualifier read new KernelArgTypeQualifier($0001);
    public static property KERNEL_ARG_TYPE_RESTRICT: KernelArgTypeQualifier read new KernelArgTypeQualifier($0002);
    public static property KERNEL_ARG_TYPE_VOLATILE: KernelArgTypeQualifier read new KernelArgTypeQualifier($0004);
    public static property KERNEL_ARG_TYPE_PIPE:     KernelArgTypeQualifier read new KernelArgTypeQualifier($0008);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0000) then Result := 'KERNEL_ARG_TYPE_NONE' else
      if self.val = UInt64($0001) then Result := 'KERNEL_ARG_TYPE_CONST' else
      if self.val = UInt64($0002) then Result := 'KERNEL_ARG_TYPE_RESTRICT' else
      if self.val = UInt64($0004) then Result := 'KERNEL_ARG_TYPE_VOLATILE' else
      if self.val = UInt64($0008) then Result := 'KERNEL_ARG_TYPE_PIPE' else
        Result := $'KernelArgTypeQualifier[{self.val}]';
    end;
    
  end;
  
  KernelExecInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_EXEC_INFO_SVM_PTRS:                          KernelExecInfo read new KernelExecInfo($11B6);
    public static property KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM:             KernelExecInfo read new KernelExecInfo($11B7);
    public static property KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM:          KernelExecInfo read new KernelExecInfo($41E5);
    public static property KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM: KernelExecInfo read new KernelExecInfo($41E6);
    public static property KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL:        KernelExecInfo read new KernelExecInfo($4200);
    public static property KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL:      KernelExecInfo read new KernelExecInfo($4201);
    public static property KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL:      KernelExecInfo read new KernelExecInfo($4202);
    public static property KERNEL_EXEC_INFO_USM_PTRS_INTEL:                    KernelExecInfo read new KernelExecInfo($4203);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11B6) then Result := 'KERNEL_EXEC_INFO_SVM_PTRS' else
      if self.val = UInt32($11B7) then Result := 'KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM' else
      if self.val = UInt32($41E5) then Result := 'KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM' else
      if self.val = UInt32($41E6) then Result := 'KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM' else
      if self.val = UInt32($4200) then Result := 'KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL' else
      if self.val = UInt32($4201) then Result := 'KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL' else
      if self.val = UInt32($4202) then Result := 'KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL' else
      if self.val = UInt32($4203) then Result := 'KERNEL_EXEC_INFO_USM_PTRS_INTEL' else
        Result := $'KernelExecInfo[{self.val}]';
    end;
    
  end;
  
  KernelExecInfoArm = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_EXEC_INFO_SVM_PTRS_ARM:              KernelExecInfoArm read new KernelExecInfoArm($40B8);
    public static property KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM: KernelExecInfoArm read new KernelExecInfoArm($40B9);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($40B8) then Result := 'KERNEL_EXEC_INFO_SVM_PTRS_ARM' else
      if self.val = UInt32($40B9) then Result := 'KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM' else
        Result := $'KernelExecInfoArm[{self.val}]';
    end;
    
  end;
  
  KernelInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_FUNCTION_NAME:   KernelInfo read new KernelInfo($1190);
    public static property KERNEL_NUM_ARGS:        KernelInfo read new KernelInfo($1191);
    public static property KERNEL_REFERENCE_COUNT: KernelInfo read new KernelInfo($1192);
    public static property KERNEL_CONTEXT:         KernelInfo read new KernelInfo($1193);
    public static property KERNEL_PROGRAM:         KernelInfo read new KernelInfo($1194);
    public static property KERNEL_ATTRIBUTES:      KernelInfo read new KernelInfo($1195);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1190) then Result := 'KERNEL_FUNCTION_NAME' else
      if self.val = UInt32($1191) then Result := 'KERNEL_NUM_ARGS' else
      if self.val = UInt32($1192) then Result := 'KERNEL_REFERENCE_COUNT' else
      if self.val = UInt32($1193) then Result := 'KERNEL_CONTEXT' else
      if self.val = UInt32($1194) then Result := 'KERNEL_PROGRAM' else
      if self.val = UInt32($1195) then Result := 'KERNEL_ATTRIBUTES' else
        Result := $'KernelInfo[{self.val}]';
    end;
    
  end;
  
  KernelSubGroupInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT:     KernelSubGroupInfo read new KernelSubGroupInfo($11B8);
    public static property KERNEL_MAX_NUM_SUB_GROUPS:                 KernelSubGroupInfo read new KernelSubGroupInfo($11B9);
    public static property KERNEL_COMPILE_NUM_SUB_GROUPS:             KernelSubGroupInfo read new KernelSubGroupInfo($11BA);
    public static property KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE:     KernelSubGroupInfo read new KernelSubGroupInfo($2033);
    public static property KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR: KernelSubGroupInfo read new KernelSubGroupInfo($2033);
    public static property KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE:        KernelSubGroupInfo read new KernelSubGroupInfo($2034);
    public static property KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR:    KernelSubGroupInfo read new KernelSubGroupInfo($2034);
    public static property KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL:       KernelSubGroupInfo read new KernelSubGroupInfo($410A);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11B8) then Result := 'KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT' else
      if self.val = UInt32($11B9) then Result := 'KERNEL_MAX_NUM_SUB_GROUPS' else
      if self.val = UInt32($11BA) then Result := 'KERNEL_COMPILE_NUM_SUB_GROUPS' else
      if self.val = UInt32($2033) then Result := 'KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE' else
      if self.val = UInt32($2033) then Result := 'KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR' else
      if self.val = UInt32($2034) then Result := 'KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE' else
      if self.val = UInt32($2034) then Result := 'KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR' else
      if self.val = UInt32($410A) then Result := 'KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL' else
        Result := $'KernelSubGroupInfo[{self.val}]';
    end;
    
  end;
  
  KernelWorkGroupInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property KERNEL_WORK_GROUP_SIZE:                    KernelWorkGroupInfo read new KernelWorkGroupInfo($11B0);
    public static property KERNEL_COMPILE_WORK_GROUP_SIZE:            KernelWorkGroupInfo read new KernelWorkGroupInfo($11B1);
    public static property KERNEL_LOCAL_MEM_SIZE:                     KernelWorkGroupInfo read new KernelWorkGroupInfo($11B2);
    public static property KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: KernelWorkGroupInfo read new KernelWorkGroupInfo($11B3);
    public static property KERNEL_PRIVATE_MEM_SIZE:                   KernelWorkGroupInfo read new KernelWorkGroupInfo($11B4);
    public static property KERNEL_GLOBAL_WORK_SIZE:                   KernelWorkGroupInfo read new KernelWorkGroupInfo($11B5);
    public static property KERNEL_SPILL_MEM_SIZE_INTEL:               KernelWorkGroupInfo read new KernelWorkGroupInfo($4109);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($11B0) then Result := 'KERNEL_WORK_GROUP_SIZE' else
      if self.val = UInt32($11B1) then Result := 'KERNEL_COMPILE_WORK_GROUP_SIZE' else
      if self.val = UInt32($11B2) then Result := 'KERNEL_LOCAL_MEM_SIZE' else
      if self.val = UInt32($11B3) then Result := 'KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE' else
      if self.val = UInt32($11B4) then Result := 'KERNEL_PRIVATE_MEM_SIZE' else
      if self.val = UInt32($11B5) then Result := 'KERNEL_GLOBAL_WORK_SIZE' else
      if self.val = UInt32($4109) then Result := 'KERNEL_SPILL_MEM_SIZE_INTEL' else
        Result := $'KernelWorkGroupInfo[{self.val}]';
    end;
    
  end;
  
  LayerInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property LAYER_API_VERSION: LayerInfo read new LayerInfo($4240);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4240) then Result := 'LAYER_API_VERSION' else
        Result := $'LayerInfo[{self.val}]';
    end;
    
  end;
  
  MapFlags = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MAP_READ:                    MapFlags read new MapFlags($0001);
    public static property MAP_WRITE:                   MapFlags read new MapFlags($0002);
    public static property MAP_WRITE_INVALIDATE_REGION: MapFlags read new MapFlags($0004);
    
    public static function operator+(f1,f2: MapFlags) := new MapFlags(f1.val or f2.val);
    public static function operator or(f1,f2: MapFlags) := f1+f2;
    
    public property HAS_FLAG_MAP_READ:                    boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_MAP_WRITE:                   boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_MAP_WRITE_INVALIDATE_REGION: boolean read self.val and $0004 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'MAP_READ+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'MAP_WRITE+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'MAP_WRITE_INVALIDATE_REGION+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'MapFlags[{self.val}]';
    end;
    
  end;
  
  MemFlags = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MEM_READ_WRITE:                      MemFlags read new MemFlags($0001);
    public static property MEM_WRITE_ONLY:                      MemFlags read new MemFlags($0002);
    public static property MEM_READ_ONLY:                       MemFlags read new MemFlags($0004);
    public static property MEM_USE_HOST_PTR:                    MemFlags read new MemFlags($0008);
    public static property MEM_ALLOC_HOST_PTR:                  MemFlags read new MemFlags($0010);
    public static property MEM_COPY_HOST_PTR:                   MemFlags read new MemFlags($0020);
    public static property MEM_HOST_WRITE_ONLY:                 MemFlags read new MemFlags($0080);
    public static property MEM_HOST_READ_ONLY:                  MemFlags read new MemFlags($0100);
    public static property MEM_HOST_NO_ACCESS:                  MemFlags read new MemFlags($0200);
    public static property MEM_KERNEL_READ_AND_WRITE:           MemFlags read new MemFlags($1000);
    public static property MEM_FORCE_HOST_MEMORY_INTEL:         MemFlags read new MemFlags($100000);
    public static property MEM_RESERVED21_INTEL:                MemFlags read new MemFlags($200000);
    public static property MEM_RESERVED22_INTEL:                MemFlags read new MemFlags($400000);
    public static property MEM_NO_ACCESS_INTEL:                 MemFlags read new MemFlags($1000000);
    public static property MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL: MemFlags read new MemFlags($2000000);
    public static property MEM_USE_UNCACHED_CPU_MEMORY_IMG:     MemFlags read new MemFlags($4000000);
    public static property MEM_USE_CACHED_CPU_MEMORY_IMG:       MemFlags read new MemFlags($8000000);
    public static property MEM_USE_GRALLOC_PTR_IMG:             MemFlags read new MemFlags($10000000);
    public static property MEM_EXT_HOST_PTR_QCOM:               MemFlags read new MemFlags($20000000);
    public static property MEM_RESERVED0_ARM:                   MemFlags read new MemFlags($100000000);
    public static property MEM_RESERVED1_ARM:                   MemFlags read new MemFlags($200000000);
    public static property MEM_RESERVED2_ARM:                   MemFlags read new MemFlags($400000000);
    public static property MEM_RESERVED3_ARM:                   MemFlags read new MemFlags($800000000);
    public static property MEM_PROTECTED_ALLOC_ARM:             MemFlags read new MemFlags($1000000000);
    public static property MEM_RESERVED0_QCOM:                  MemFlags read new MemFlags($2000000000);
    public static property MEM_RESERVED1_QCOM:                  MemFlags read new MemFlags($4000000000);
    public static property MEM_RESERVED2_QCOM:                  MemFlags read new MemFlags($8000000000);
    public static property MEM_RESERVED3_QCOM:                  MemFlags read new MemFlags($10000000000);
    
    public static function operator+(f1,f2: MemFlags) := new MemFlags(f1.val or f2.val);
    public static function operator or(f1,f2: MemFlags) := f1+f2;
    
    public property HAS_FLAG_MEM_READ_WRITE:                      boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_MEM_WRITE_ONLY:                      boolean read self.val and $0002 <> 0;
    public property HAS_FLAG_MEM_READ_ONLY:                       boolean read self.val and $0004 <> 0;
    public property HAS_FLAG_MEM_USE_HOST_PTR:                    boolean read self.val and $0008 <> 0;
    public property HAS_FLAG_MEM_ALLOC_HOST_PTR:                  boolean read self.val and $0010 <> 0;
    public property HAS_FLAG_MEM_COPY_HOST_PTR:                   boolean read self.val and $0020 <> 0;
    public property HAS_FLAG_MEM_HOST_WRITE_ONLY:                 boolean read self.val and $0080 <> 0;
    public property HAS_FLAG_MEM_HOST_READ_ONLY:                  boolean read self.val and $0100 <> 0;
    public property HAS_FLAG_MEM_HOST_NO_ACCESS:                  boolean read self.val and $0200 <> 0;
    public property HAS_FLAG_MEM_KERNEL_READ_AND_WRITE:           boolean read self.val and $1000 <> 0;
    public property HAS_FLAG_MEM_FORCE_HOST_MEMORY_INTEL:         boolean read self.val and $100000 <> 0;
    public property HAS_FLAG_MEM_RESERVED21_INTEL:                boolean read self.val and $200000 <> 0;
    public property HAS_FLAG_MEM_RESERVED22_INTEL:                boolean read self.val and $400000 <> 0;
    public property HAS_FLAG_MEM_NO_ACCESS_INTEL:                 boolean read self.val and $1000000 <> 0;
    public property HAS_FLAG_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL: boolean read self.val and $2000000 <> 0;
    public property HAS_FLAG_MEM_USE_UNCACHED_CPU_MEMORY_IMG:     boolean read self.val and $4000000 <> 0;
    public property HAS_FLAG_MEM_USE_CACHED_CPU_MEMORY_IMG:       boolean read self.val and $8000000 <> 0;
    public property HAS_FLAG_MEM_USE_GRALLOC_PTR_IMG:             boolean read self.val and $10000000 <> 0;
    public property HAS_FLAG_MEM_EXT_HOST_PTR_QCOM:               boolean read self.val and $20000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED0_ARM:                   boolean read self.val and $100000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED1_ARM:                   boolean read self.val and $200000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED2_ARM:                   boolean read self.val and $400000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED3_ARM:                   boolean read self.val and $800000000 <> 0;
    public property HAS_FLAG_MEM_PROTECTED_ALLOC_ARM:             boolean read self.val and $1000000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED0_QCOM:                  boolean read self.val and $2000000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED1_QCOM:                  boolean read self.val and $4000000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED2_QCOM:                  boolean read self.val and $8000000000 <> 0;
    public property HAS_FLAG_MEM_RESERVED3_QCOM:                  boolean read self.val and $10000000000 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'MEM_READ_WRITE+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'MEM_WRITE_ONLY+';
      if self.val and UInt64($0004) = UInt64($0004) then res += 'MEM_READ_ONLY+';
      if self.val and UInt64($0008) = UInt64($0008) then res += 'MEM_USE_HOST_PTR+';
      if self.val and UInt64($0010) = UInt64($0010) then res += 'MEM_ALLOC_HOST_PTR+';
      if self.val and UInt64($0020) = UInt64($0020) then res += 'MEM_COPY_HOST_PTR+';
      if self.val and UInt64($0080) = UInt64($0080) then res += 'MEM_HOST_WRITE_ONLY+';
      if self.val and UInt64($0100) = UInt64($0100) then res += 'MEM_HOST_READ_ONLY+';
      if self.val and UInt64($0200) = UInt64($0200) then res += 'MEM_HOST_NO_ACCESS+';
      if self.val and UInt64($1000) = UInt64($1000) then res += 'MEM_KERNEL_READ_AND_WRITE+';
      if self.val and UInt64($100000) = UInt64($100000) then res += 'MEM_FORCE_HOST_MEMORY_INTEL+';
      if self.val and UInt64($200000) = UInt64($200000) then res += 'MEM_RESERVED21_INTEL+';
      if self.val and UInt64($400000) = UInt64($400000) then res += 'MEM_RESERVED22_INTEL+';
      if self.val and UInt64($1000000) = UInt64($1000000) then res += 'MEM_NO_ACCESS_INTEL+';
      if self.val and UInt64($2000000) = UInt64($2000000) then res += 'MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL+';
      if self.val and UInt64($4000000) = UInt64($4000000) then res += 'MEM_USE_UNCACHED_CPU_MEMORY_IMG+';
      if self.val and UInt64($8000000) = UInt64($8000000) then res += 'MEM_USE_CACHED_CPU_MEMORY_IMG+';
      if self.val and UInt64($10000000) = UInt64($10000000) then res += 'MEM_USE_GRALLOC_PTR_IMG+';
      if self.val and UInt64($20000000) = UInt64($20000000) then res += 'MEM_EXT_HOST_PTR_QCOM+';
      if self.val and UInt64($100000000) = UInt64($100000000) then res += 'MEM_RESERVED0_ARM+';
      if self.val and UInt64($200000000) = UInt64($200000000) then res += 'MEM_RESERVED1_ARM+';
      if self.val and UInt64($400000000) = UInt64($400000000) then res += 'MEM_RESERVED2_ARM+';
      if self.val and UInt64($800000000) = UInt64($800000000) then res += 'MEM_RESERVED3_ARM+';
      if self.val and UInt64($1000000000) = UInt64($1000000000) then res += 'MEM_PROTECTED_ALLOC_ARM+';
      if self.val and UInt64($2000000000) = UInt64($2000000000) then res += 'MEM_RESERVED0_QCOM+';
      if self.val and UInt64($4000000000) = UInt64($4000000000) then res += 'MEM_RESERVED1_QCOM+';
      if self.val and UInt64($8000000000) = UInt64($8000000000) then res += 'MEM_RESERVED2_QCOM+';
      if self.val and UInt64($10000000000) = UInt64($10000000000) then res += 'MEM_RESERVED3_QCOM+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'MemFlags[{self.val}]';
    end;
    
  end;
  
  MemInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property MEM_TYPE:                       MemInfo read new MemInfo($1100);
    public static property MEM_FLAGS:                      MemInfo read new MemInfo($1101);
    public static property MEM_SIZE:                       MemInfo read new MemInfo($1102);
    public static property MEM_HOST_PTR:                   MemInfo read new MemInfo($1103);
    public static property MEM_MAP_COUNT:                  MemInfo read new MemInfo($1104);
    public static property MEM_REFERENCE_COUNT:            MemInfo read new MemInfo($1105);
    public static property MEM_CONTEXT:                    MemInfo read new MemInfo($1106);
    public static property MEM_ASSOCIATED_MEMOBJECT:       MemInfo read new MemInfo($1107);
    public static property MEM_OFFSET:                     MemInfo read new MemInfo($1108);
    public static property MEM_USES_SVM_POINTER:           MemInfo read new MemInfo($1109);
    public static property MEM_PROPERTIES:                 MemInfo read new MemInfo($110A);
    public static property MEM_DX9_MEDIA_ADAPTER_TYPE_KHR: MemInfo read new MemInfo($2028);
    public static property MEM_DX9_MEDIA_SURFACE_INFO_KHR: MemInfo read new MemInfo($2029);
    public static property MEM_D3D10_RESOURCE_KHR:         MemInfo read new MemInfo($4015);
    public static property MEM_D3D11_RESOURCE_KHR:         MemInfo read new MemInfo($401E);
    public static property MEM_DX9_RESOURCE_INTEL:         MemInfo read new MemInfo($4027);
    public static property MEM_DX9_SHARED_HANDLE_INTEL:    MemInfo read new MemInfo($4074);
    public static property MEM_VA_API_MEDIA_SURFACE_INTEL: MemInfo read new MemInfo($4098);
    public static property MEM_USES_SVM_POINTER_ARM:       MemInfo read new MemInfo($40B7);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1100) then Result := 'MEM_TYPE' else
      if self.val = UInt32($1101) then Result := 'MEM_FLAGS' else
      if self.val = UInt32($1102) then Result := 'MEM_SIZE' else
      if self.val = UInt32($1103) then Result := 'MEM_HOST_PTR' else
      if self.val = UInt32($1104) then Result := 'MEM_MAP_COUNT' else
      if self.val = UInt32($1105) then Result := 'MEM_REFERENCE_COUNT' else
      if self.val = UInt32($1106) then Result := 'MEM_CONTEXT' else
      if self.val = UInt32($1107) then Result := 'MEM_ASSOCIATED_MEMOBJECT' else
      if self.val = UInt32($1108) then Result := 'MEM_OFFSET' else
      if self.val = UInt32($1109) then Result := 'MEM_USES_SVM_POINTER' else
      if self.val = UInt32($110A) then Result := 'MEM_PROPERTIES' else
      if self.val = UInt32($2028) then Result := 'MEM_DX9_MEDIA_ADAPTER_TYPE_KHR' else
      if self.val = UInt32($2029) then Result := 'MEM_DX9_MEDIA_SURFACE_INFO_KHR' else
      if self.val = UInt32($4015) then Result := 'MEM_D3D10_RESOURCE_KHR' else
      if self.val = UInt32($401E) then Result := 'MEM_D3D11_RESOURCE_KHR' else
      if self.val = UInt32($4027) then Result := 'MEM_DX9_RESOURCE_INTEL' else
      if self.val = UInt32($4074) then Result := 'MEM_DX9_SHARED_HANDLE_INTEL' else
      if self.val = UInt32($4098) then Result := 'MEM_VA_API_MEDIA_SURFACE_INTEL' else
      if self.val = UInt32($40B7) then Result := 'MEM_USES_SVM_POINTER_ARM' else
        Result := $'MemInfo[{self.val}]';
    end;
    
  end;
  
  MemMigrationFlags = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MIGRATE_MEM_OBJECT_HOST:              MemMigrationFlags read new MemMigrationFlags($0001);
    public static property MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED: MemMigrationFlags read new MemMigrationFlags($0002);
    
    public static function operator+(f1,f2: MemMigrationFlags) := new MemMigrationFlags(f1.val or f2.val);
    public static function operator or(f1,f2: MemMigrationFlags) := f1+f2;
    
    public property HAS_FLAG_MIGRATE_MEM_OBJECT_HOST:              boolean read self.val and $0001 <> 0;
    public property HAS_FLAG_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED: boolean read self.val and $0002 <> 0;
    
    public function ToString: string; override;
    begin
      var res := new StringBuilder;
      if self.val and UInt64($0001) = UInt64($0001) then res += 'MIGRATE_MEM_OBJECT_HOST+';
      if self.val and UInt64($0002) = UInt64($0002) then res += 'MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED+';
      if res.Length<>0 then
      begin
        res.Length -= 1;
        Result := res.ToString;
      end else
        Result := $'MemMigrationFlags[{self.val}]';
    end;
    
  end;
  
  MemMigrationFlagsExt = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MIGRATE_MEM_OBJECT_HOST_EXT: MemMigrationFlagsExt read new MemMigrationFlagsExt($0001);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0001) then Result := 'MIGRATE_MEM_OBJECT_HOST_EXT' else
        Result := $'MemMigrationFlagsExt[{self.val}]';
    end;
    
  end;
  
  MemObjectType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property MEM_OBJECT_BUFFER:         MemObjectType read new MemObjectType($10F0);
    public static property MEM_OBJECT_IMAGE2D:        MemObjectType read new MemObjectType($10F1);
    public static property MEM_OBJECT_IMAGE3D:        MemObjectType read new MemObjectType($10F2);
    public static property MEM_OBJECT_IMAGE2D_ARRAY:  MemObjectType read new MemObjectType($10F3);
    public static property MEM_OBJECT_IMAGE1D:        MemObjectType read new MemObjectType($10F4);
    public static property MEM_OBJECT_IMAGE1D_ARRAY:  MemObjectType read new MemObjectType($10F5);
    public static property MEM_OBJECT_IMAGE1D_BUFFER: MemObjectType read new MemObjectType($10F6);
    public static property MEM_OBJECT_PIPE:           MemObjectType read new MemObjectType($10F7);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($10F0) then Result := 'MEM_OBJECT_BUFFER' else
      if self.val = UInt32($10F1) then Result := 'MEM_OBJECT_IMAGE2D' else
      if self.val = UInt32($10F2) then Result := 'MEM_OBJECT_IMAGE3D' else
      if self.val = UInt32($10F3) then Result := 'MEM_OBJECT_IMAGE2D_ARRAY' else
      if self.val = UInt32($10F4) then Result := 'MEM_OBJECT_IMAGE1D' else
      if self.val = UInt32($10F5) then Result := 'MEM_OBJECT_IMAGE1D_ARRAY' else
      if self.val = UInt32($10F6) then Result := 'MEM_OBJECT_IMAGE1D_BUFFER' else
      if self.val = UInt32($10F7) then Result := 'MEM_OBJECT_PIPE' else
        Result := $'MemObjectType[{self.val}]';
    end;
    
  end;
  
  MemProperties = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property DEVICE_HANDLE_LIST_END_KHR: MemProperties read new MemProperties($0000);
    public static property DEVICE_HANDLE_LIST_KHR:     MemProperties read new MemProperties($2051);
    public static property MEM_ALLOC_FLAGS_IMG:        MemProperties read new MemProperties($40D7);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0000) then Result := 'DEVICE_HANDLE_LIST_END_KHR' else
      if self.val = UInt64($2051) then Result := 'DEVICE_HANDLE_LIST_KHR' else
      if self.val = UInt64($40D7) then Result := 'MEM_ALLOC_FLAGS_IMG' else
        Result := $'MemProperties[{self.val}]';
    end;
    
  end;
  
  MemPropertiesIntel = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MEM_ALLOC_FLAGS_INTEL:           MemPropertiesIntel read new MemPropertiesIntel($4195);
    public static property MEM_ALLOC_BUFFER_LOCATION_INTEL: MemPropertiesIntel read new MemPropertiesIntel($419E);
    public static property MEM_CHANNEL_INTEL:               MemPropertiesIntel read new MemPropertiesIntel($4213);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($4195) then Result := 'MEM_ALLOC_FLAGS_INTEL' else
      if self.val = UInt64($419E) then Result := 'MEM_ALLOC_BUFFER_LOCATION_INTEL' else
      if self.val = UInt64($4213) then Result := 'MEM_CHANNEL_INTEL' else
        Result := $'MemPropertiesIntel[{self.val}]';
    end;
    
  end;
  
  MipmapFilterModeImg = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property MIPMAP_FILTER_ANY_IMG: MipmapFilterModeImg read new MipmapFilterModeImg($0000);
    public static property MIPMAP_FILTER_BOX_IMG: MipmapFilterModeImg read new MipmapFilterModeImg($0001);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'MIPMAP_FILTER_ANY_IMG' else
      if self.val = UInt32($0001) then Result := 'MIPMAP_FILTER_BOX_IMG' else
        Result := $'MipmapFilterModeImg[{self.val}]';
    end;
    
  end;
  
  PipeInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PIPE_PACKET_SIZE: PipeInfo read new PipeInfo($1120);
    public static property PIPE_MAX_PACKETS: PipeInfo read new PipeInfo($1121);
    public static property PIPE_PROPERTIES:  PipeInfo read new PipeInfo($1122);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1120) then Result := 'PIPE_PACKET_SIZE' else
      if self.val = UInt32($1121) then Result := 'PIPE_MAX_PACKETS' else
      if self.val = UInt32($1122) then Result := 'PIPE_PROPERTIES' else
        Result := $'PipeInfo[{self.val}]';
    end;
    
  end;
  
  PlatformInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PLATFORM_PROFILE:                                 PlatformInfo read new PlatformInfo($0900);
    public static property PLATFORM_VERSION:                                 PlatformInfo read new PlatformInfo($0901);
    public static property PLATFORM_NAME:                                    PlatformInfo read new PlatformInfo($0902);
    public static property PLATFORM_VENDOR:                                  PlatformInfo read new PlatformInfo($0903);
    public static property PLATFORM_EXTENSIONS:                              PlatformInfo read new PlatformInfo($0904);
    public static property PLATFORM_HOST_TIMER_RESOLUTION:                   PlatformInfo read new PlatformInfo($0905);
    public static property PLATFORM_NUMERIC_VERSION:                         PlatformInfo read new PlatformInfo($0906);
    public static property PLATFORM_NUMERIC_VERSION_KHR:                     PlatformInfo read new PlatformInfo($0906);
    public static property PLATFORM_EXTENSIONS_WITH_VERSION:                 PlatformInfo read new PlatformInfo($0907);
    public static property PLATFORM_EXTENSIONS_WITH_VERSION_KHR:             PlatformInfo read new PlatformInfo($0907);
    public static property PLATFORM_ICD_SUFFIX_KHR:                          PlatformInfo read new PlatformInfo($0920);
    public static property PLATFORM_SEMAPHORE_TYPES_KHR:                     PlatformInfo read new PlatformInfo($2036);
    public static property PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR:       PlatformInfo read new PlatformInfo($2037);
    public static property PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR:       PlatformInfo read new PlatformInfo($2038);
    public static property PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR: PlatformInfo read new PlatformInfo($2044);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0900) then Result := 'PLATFORM_PROFILE' else
      if self.val = UInt32($0901) then Result := 'PLATFORM_VERSION' else
      if self.val = UInt32($0902) then Result := 'PLATFORM_NAME' else
      if self.val = UInt32($0903) then Result := 'PLATFORM_VENDOR' else
      if self.val = UInt32($0904) then Result := 'PLATFORM_EXTENSIONS' else
      if self.val = UInt32($0905) then Result := 'PLATFORM_HOST_TIMER_RESOLUTION' else
      if self.val = UInt32($0906) then Result := 'PLATFORM_NUMERIC_VERSION' else
      if self.val = UInt32($0906) then Result := 'PLATFORM_NUMERIC_VERSION_KHR' else
      if self.val = UInt32($0907) then Result := 'PLATFORM_EXTENSIONS_WITH_VERSION' else
      if self.val = UInt32($0907) then Result := 'PLATFORM_EXTENSIONS_WITH_VERSION_KHR' else
      if self.val = UInt32($0920) then Result := 'PLATFORM_ICD_SUFFIX_KHR' else
      if self.val = UInt32($2036) then Result := 'PLATFORM_SEMAPHORE_TYPES_KHR' else
      if self.val = UInt32($2037) then Result := 'PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt32($2038) then Result := 'PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt32($2044) then Result := 'PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR' else
        Result := $'PlatformInfo[{self.val}]';
    end;
    
  end;
  
  ProfilingInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PROFILING_COMMAND_QUEUED:   ProfilingInfo read new ProfilingInfo($1280);
    public static property PROFILING_COMMAND_SUBMIT:   ProfilingInfo read new ProfilingInfo($1281);
    public static property PROFILING_COMMAND_START:    ProfilingInfo read new ProfilingInfo($1282);
    public static property PROFILING_COMMAND_END:      ProfilingInfo read new ProfilingInfo($1283);
    public static property PROFILING_COMMAND_COMPLETE: ProfilingInfo read new ProfilingInfo($1284);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1280) then Result := 'PROFILING_COMMAND_QUEUED' else
      if self.val = UInt32($1281) then Result := 'PROFILING_COMMAND_SUBMIT' else
      if self.val = UInt32($1282) then Result := 'PROFILING_COMMAND_START' else
      if self.val = UInt32($1283) then Result := 'PROFILING_COMMAND_END' else
      if self.val = UInt32($1284) then Result := 'PROFILING_COMMAND_COMPLETE' else
        Result := $'ProfilingInfo[{self.val}]';
    end;
    
  end;
  
  ProgramBinaryType = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PROGRAM_BINARY_TYPE_NONE:            ProgramBinaryType read new ProgramBinaryType($0000);
    public static property PROGRAM_BINARY_TYPE_COMPILED_OBJECT: ProgramBinaryType read new ProgramBinaryType($0001);
    public static property PROGRAM_BINARY_TYPE_LIBRARY:         ProgramBinaryType read new ProgramBinaryType($0002);
    public static property PROGRAM_BINARY_TYPE_EXECUTABLE:      ProgramBinaryType read new ProgramBinaryType($0004);
    public static property PROGRAM_BINARY_TYPE_INTERMEDIATE:    ProgramBinaryType read new ProgramBinaryType($40E1);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'PROGRAM_BINARY_TYPE_NONE' else
      if self.val = UInt32($0001) then Result := 'PROGRAM_BINARY_TYPE_COMPILED_OBJECT' else
      if self.val = UInt32($0002) then Result := 'PROGRAM_BINARY_TYPE_LIBRARY' else
      if self.val = UInt32($0004) then Result := 'PROGRAM_BINARY_TYPE_EXECUTABLE' else
      if self.val = UInt32($40E1) then Result := 'PROGRAM_BINARY_TYPE_INTERMEDIATE' else
        Result := $'ProgramBinaryType[{self.val}]';
    end;
    
  end;
  
  ProgramBuildInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PROGRAM_BUILD_STATUS:                     ProgramBuildInfo read new ProgramBuildInfo($1181);
    public static property PROGRAM_BUILD_OPTIONS:                    ProgramBuildInfo read new ProgramBuildInfo($1182);
    public static property PROGRAM_BUILD_LOG:                        ProgramBuildInfo read new ProgramBuildInfo($1183);
    public static property PROGRAM_BINARY_TYPE:                      ProgramBuildInfo read new ProgramBuildInfo($1184);
    public static property PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE: ProgramBuildInfo read new ProgramBuildInfo($1185);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1181) then Result := 'PROGRAM_BUILD_STATUS' else
      if self.val = UInt32($1182) then Result := 'PROGRAM_BUILD_OPTIONS' else
      if self.val = UInt32($1183) then Result := 'PROGRAM_BUILD_LOG' else
      if self.val = UInt32($1184) then Result := 'PROGRAM_BINARY_TYPE' else
      if self.val = UInt32($1185) then Result := 'PROGRAM_BUILD_GLOBAL_VARIABLE_TOTAL_SIZE' else
        Result := $'ProgramBuildInfo[{self.val}]';
    end;
    
  end;
  
  ProgramInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PROGRAM_REFERENCE_COUNT:            ProgramInfo read new ProgramInfo($1160);
    public static property PROGRAM_CONTEXT:                    ProgramInfo read new ProgramInfo($1161);
    public static property PROGRAM_NUM_DEVICES:                ProgramInfo read new ProgramInfo($1162);
    public static property PROGRAM_DEVICES:                    ProgramInfo read new ProgramInfo($1163);
    public static property PROGRAM_SOURCE:                     ProgramInfo read new ProgramInfo($1164);
    public static property PROGRAM_BINARY_SIZES:               ProgramInfo read new ProgramInfo($1165);
    public static property PROGRAM_BINARIES:                   ProgramInfo read new ProgramInfo($1166);
    public static property PROGRAM_NUM_KERNELS:                ProgramInfo read new ProgramInfo($1167);
    public static property PROGRAM_KERNEL_NAMES:               ProgramInfo read new ProgramInfo($1168);
    public static property PROGRAM_IL:                         ProgramInfo read new ProgramInfo($1169);
    public static property PROGRAM_IL_KHR:                     ProgramInfo read new ProgramInfo($1169);
    public static property PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT: ProgramInfo read new ProgramInfo($116A);
    public static property PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT: ProgramInfo read new ProgramInfo($116B);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1160) then Result := 'PROGRAM_REFERENCE_COUNT' else
      if self.val = UInt32($1161) then Result := 'PROGRAM_CONTEXT' else
      if self.val = UInt32($1162) then Result := 'PROGRAM_NUM_DEVICES' else
      if self.val = UInt32($1163) then Result := 'PROGRAM_DEVICES' else
      if self.val = UInt32($1164) then Result := 'PROGRAM_SOURCE' else
      if self.val = UInt32($1165) then Result := 'PROGRAM_BINARY_SIZES' else
      if self.val = UInt32($1166) then Result := 'PROGRAM_BINARIES' else
      if self.val = UInt32($1167) then Result := 'PROGRAM_NUM_KERNELS' else
      if self.val = UInt32($1168) then Result := 'PROGRAM_KERNEL_NAMES' else
      if self.val = UInt32($1169) then Result := 'PROGRAM_IL' else
      if self.val = UInt32($1169) then Result := 'PROGRAM_IL_KHR' else
      if self.val = UInt32($116A) then Result := 'PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT' else
      if self.val = UInt32($116B) then Result := 'PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT' else
        Result := $'ProgramInfo[{self.val}]';
    end;
    
  end;
  
  QueueProperties = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property QUEUE_PRIORITY_KHR:        QueueProperties read new QueueProperties($1096);
    public static property QUEUE_THROTTLE_KHR:        QueueProperties read new QueueProperties($1097);
    public static property QUEUE_FAMILY_INTEL:        QueueProperties read new QueueProperties($418C);
    public static property QUEUE_INDEX_INTEL:         QueueProperties read new QueueProperties($418D);
    public static property QUEUE_KERNEL_BATCHING_ARM: QueueProperties read new QueueProperties($41E7);
    public static property QUEUE_DEFERRED_FLUSH_ARM:  QueueProperties read new QueueProperties($41EC);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($1096) then Result := 'QUEUE_PRIORITY_KHR' else
      if self.val = UInt64($1097) then Result := 'QUEUE_THROTTLE_KHR' else
      if self.val = UInt64($418C) then Result := 'QUEUE_FAMILY_INTEL' else
      if self.val = UInt64($418D) then Result := 'QUEUE_INDEX_INTEL' else
      if self.val = UInt64($41E7) then Result := 'QUEUE_KERNEL_BATCHING_ARM' else
      if self.val = UInt64($41EC) then Result := 'QUEUE_DEFERRED_FLUSH_ARM' else
        Result := $'QueueProperties[{self.val}]';
    end;
    
  end;
  
  SamplerInfo = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property SAMPLER_REFERENCE_COUNT:   SamplerInfo read new SamplerInfo($1150);
    public static property SAMPLER_CONTEXT:           SamplerInfo read new SamplerInfo($1151);
    public static property SAMPLER_NORMALIZED_COORDS: SamplerInfo read new SamplerInfo($1152);
    public static property SAMPLER_ADDRESSING_MODE:   SamplerInfo read new SamplerInfo($1153);
    public static property SAMPLER_FILTER_MODE:       SamplerInfo read new SamplerInfo($1154);
    public static property SAMPLER_MIP_FILTER_MODE:   SamplerInfo read new SamplerInfo($1155);
    public static property SAMPLER_LOD_MIN:           SamplerInfo read new SamplerInfo($1156);
    public static property SAMPLER_LOD_MAX:           SamplerInfo read new SamplerInfo($1157);
    public static property SAMPLER_PROPERTIES:        SamplerInfo read new SamplerInfo($1158);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($1150) then Result := 'SAMPLER_REFERENCE_COUNT' else
      if self.val = UInt32($1151) then Result := 'SAMPLER_CONTEXT' else
      if self.val = UInt32($1152) then Result := 'SAMPLER_NORMALIZED_COORDS' else
      if self.val = UInt32($1153) then Result := 'SAMPLER_ADDRESSING_MODE' else
      if self.val = UInt32($1154) then Result := 'SAMPLER_FILTER_MODE' else
      if self.val = UInt32($1155) then Result := 'SAMPLER_MIP_FILTER_MODE' else
      if self.val = UInt32($1156) then Result := 'SAMPLER_LOD_MIN' else
      if self.val = UInt32($1157) then Result := 'SAMPLER_LOD_MAX' else
      if self.val = UInt32($1158) then Result := 'SAMPLER_PROPERTIES' else
        Result := $'SamplerInfo[{self.val}]';
    end;
    
  end;
  
  SamplerProperties = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property SAMPLER_MIP_FILTER_MODE_KHR: SamplerProperties read new SamplerProperties($1155);
    public static property SAMPLER_LOD_MIN_KHR:         SamplerProperties read new SamplerProperties($1156);
    public static property SAMPLER_LOD_MAX_KHR:         SamplerProperties read new SamplerProperties($1157);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($1155) then Result := 'SAMPLER_MIP_FILTER_MODE_KHR' else
      if self.val = UInt64($1156) then Result := 'SAMPLER_LOD_MIN_KHR' else
      if self.val = UInt64($1157) then Result := 'SAMPLER_LOD_MAX_KHR' else
        Result := $'SamplerProperties[{self.val}]';
    end;
    
  end;
  
  SemaphoreInfoKhr = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property DEVICE_HANDLE_LIST_END_KHR:    SemaphoreInfoKhr read new SemaphoreInfoKhr($0000);
    public static property SEMAPHORE_CONTEXT_KHR:         SemaphoreInfoKhr read new SemaphoreInfoKhr($2039);
    public static property SEMAPHORE_REFERENCE_COUNT_KHR: SemaphoreInfoKhr read new SemaphoreInfoKhr($203A);
    public static property SEMAPHORE_PROPERTIES_KHR:      SemaphoreInfoKhr read new SemaphoreInfoKhr($203B);
    public static property SEMAPHORE_PAYLOAD_KHR:         SemaphoreInfoKhr read new SemaphoreInfoKhr($203C);
    public static property SEMAPHORE_TYPE_KHR:            SemaphoreInfoKhr read new SemaphoreInfoKhr($203D);
    public static property DEVICE_HANDLE_LIST_KHR:        SemaphoreInfoKhr read new SemaphoreInfoKhr($2051);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($0000) then Result := 'DEVICE_HANDLE_LIST_END_KHR' else
      if self.val = UInt32($2039) then Result := 'SEMAPHORE_CONTEXT_KHR' else
      if self.val = UInt32($203A) then Result := 'SEMAPHORE_REFERENCE_COUNT_KHR' else
      if self.val = UInt32($203B) then Result := 'SEMAPHORE_PROPERTIES_KHR' else
      if self.val = UInt32($203C) then Result := 'SEMAPHORE_PAYLOAD_KHR' else
      if self.val = UInt32($203D) then Result := 'SEMAPHORE_TYPE_KHR' else
      if self.val = UInt32($2051) then Result := 'DEVICE_HANDLE_LIST_KHR' else
        Result := $'SemaphoreInfoKhr[{self.val}]';
    end;
    
  end;
  
  SemaphorePropertiesKhr = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property DEVICE_HANDLE_LIST_END_KHR:                 SemaphorePropertiesKhr read new SemaphorePropertiesKhr($0000);
    public static property SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR: SemaphorePropertiesKhr read new SemaphorePropertiesKhr($0000);
    public static property SEMAPHORE_TYPE_KHR:                         SemaphorePropertiesKhr read new SemaphorePropertiesKhr($203D);
    public static property SEMAPHORE_EXPORT_HANDLE_TYPES_KHR:          SemaphorePropertiesKhr read new SemaphorePropertiesKhr($203F);
    public static property DEVICE_HANDLE_LIST_KHR:                     SemaphorePropertiesKhr read new SemaphorePropertiesKhr($2051);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0000) then Result := 'DEVICE_HANDLE_LIST_END_KHR' else
      if self.val = UInt64($0000) then Result := 'SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR' else
      if self.val = UInt64($203D) then Result := 'SEMAPHORE_TYPE_KHR' else
      if self.val = UInt64($203F) then Result := 'SEMAPHORE_EXPORT_HANDLE_TYPES_KHR' else
      if self.val = UInt64($2051) then Result := 'DEVICE_HANDLE_LIST_KHR' else
        Result := $'SemaphorePropertiesKhr[{self.val}]';
    end;
    
  end;
  
  SvmMemFlags = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MEM_READ_WRITE:            SvmMemFlags read new SvmMemFlags($0001);
    public static property MEM_WRITE_ONLY:            SvmMemFlags read new SvmMemFlags($0002);
    public static property MEM_READ_ONLY:             SvmMemFlags read new SvmMemFlags($0004);
    public static property MEM_USE_HOST_PTR:          SvmMemFlags read new SvmMemFlags($0008);
    public static property MEM_ALLOC_HOST_PTR:        SvmMemFlags read new SvmMemFlags($0010);
    public static property MEM_COPY_HOST_PTR:         SvmMemFlags read new SvmMemFlags($0020);
    public static property MEM_HOST_WRITE_ONLY:       SvmMemFlags read new SvmMemFlags($0080);
    public static property MEM_HOST_READ_ONLY:        SvmMemFlags read new SvmMemFlags($0100);
    public static property MEM_HOST_NO_ACCESS:        SvmMemFlags read new SvmMemFlags($0200);
    public static property MEM_SVM_FINE_GRAIN_BUFFER: SvmMemFlags read new SvmMemFlags($0400);
    public static property MEM_SVM_ATOMICS:           SvmMemFlags read new SvmMemFlags($0800);
    public static property MEM_KERNEL_READ_AND_WRITE: SvmMemFlags read new SvmMemFlags($1000);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0001) then Result := 'MEM_READ_WRITE' else
      if self.val = UInt64($0002) then Result := 'MEM_WRITE_ONLY' else
      if self.val = UInt64($0004) then Result := 'MEM_READ_ONLY' else
      if self.val = UInt64($0008) then Result := 'MEM_USE_HOST_PTR' else
      if self.val = UInt64($0010) then Result := 'MEM_ALLOC_HOST_PTR' else
      if self.val = UInt64($0020) then Result := 'MEM_COPY_HOST_PTR' else
      if self.val = UInt64($0080) then Result := 'MEM_HOST_WRITE_ONLY' else
      if self.val = UInt64($0100) then Result := 'MEM_HOST_READ_ONLY' else
      if self.val = UInt64($0200) then Result := 'MEM_HOST_NO_ACCESS' else
      if self.val = UInt64($0400) then Result := 'MEM_SVM_FINE_GRAIN_BUFFER' else
      if self.val = UInt64($0800) then Result := 'MEM_SVM_ATOMICS' else
      if self.val = UInt64($1000) then Result := 'MEM_KERNEL_READ_AND_WRITE' else
        Result := $'SvmMemFlags[{self.val}]';
    end;
    
  end;
  
  SvmMemFlagsArm = record
    public val: UInt64;
    public constructor(val: UInt64) := self.val := val;
    
    public static property MEM_SVM_FINE_GRAIN_BUFFER_ARM: SvmMemFlagsArm read new SvmMemFlagsArm($0400);
    public static property MEM_SVM_ATOMICS_ARM:           SvmMemFlagsArm read new SvmMemFlagsArm($0800);
    
    public function ToString: string; override;
    begin
      if self.val = UInt64($0400) then Result := 'MEM_SVM_FINE_GRAIN_BUFFER_ARM' else
      if self.val = UInt64($0800) then Result := 'MEM_SVM_ATOMICS_ARM' else
        Result := $'SvmMemFlagsArm[{self.val}]';
    end;
    
  end;
  
  VaApiDeviceSetIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property PREFERRED_DEVICES_FOR_VA_API_INTEL: VaApiDeviceSetIntel read new VaApiDeviceSetIntel($4095);
    public static property ALL_DEVICES_FOR_VA_API_INTEL:       VaApiDeviceSetIntel read new VaApiDeviceSetIntel($4096);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4095) then Result := 'PREFERRED_DEVICES_FOR_VA_API_INTEL' else
      if self.val = UInt32($4096) then Result := 'ALL_DEVICES_FOR_VA_API_INTEL' else
        Result := $'VaApiDeviceSetIntel[{self.val}]';
    end;
    
  end;
  
  VaApiDeviceSourceIntel = record
    public val: UInt32;
    public constructor(val: UInt32) := self.val := val;
    
    public static property VA_API_DISPLAY_INTEL: VaApiDeviceSourceIntel read new VaApiDeviceSourceIntel($4094);
    
    public function ToString: string; override;
    begin
      if self.val = UInt32($4094) then Result := 'VA_API_DISPLAY_INTEL' else
        Result := $'VaApiDeviceSourceIntel[{self.val}]';
    end;
    
  end;
  
  {$endregion Core}
  
  {$endregion Перечисления}
  
  {$region Делегаты}
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  ProgramCallback = procedure(&program: cl_program; user_data: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  CreateContextCallback = procedure(errinfo: IntPtr; private_info: IntPtr; cb: UInt32; user_data: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  ContextDestructorCallback = procedure(context: cl_context; user_data: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  EnqueueNativeKernelCallback = procedure(args: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  EnqueueSVMFreeCallback = procedure(queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; user_data: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  EventCallback = procedure(&event: cl_event; event_command_status: CommandExecutionStatus; user_data: IntPtr);
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  MemObjectDestructorCallback = procedure(memobj: cl_mem; user_data: IntPtr);
  
  {$endregion Делегаты}
  
  {$region Записи}
  
  cl_buffer_region = record
    public origin: UIntPtr;
    public size: UIntPtr;
    
    public constructor(origin: UIntPtr; size: UIntPtr);
    begin
      self.origin := origin;
      self.size := size;
    end;
    
  end;
  
  cl_image_desc = record
    public image_type: MemObjectType;
    public image_width: UIntPtr;
    public image_height: UIntPtr;
    public image_depth: UIntPtr;
    public image_array_size: UIntPtr;
    public image_row_pitch: UIntPtr;
    public image_slice_pitch: UIntPtr;
    public num_mip_levels: UInt32;
    public num_samples: UInt32;
    public mem_object: cl_mem;
    
    public constructor(image_type: MemObjectType; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_array_size: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; num_mip_levels: UInt32; num_samples: UInt32; mem_object: cl_mem);
    begin
      self.image_type := image_type;
      self.image_width := image_width;
      self.image_height := image_height;
      self.image_depth := image_depth;
      self.image_array_size := image_array_size;
      self.image_row_pitch := image_row_pitch;
      self.image_slice_pitch := image_slice_pitch;
      self.num_mip_levels := num_mip_levels;
      self.num_samples := num_samples;
      self.mem_object := mem_object;
    end;
    
  end;
  
  cl_image_format = record
    public image_channel_order: ChannelOrder;
    public image_channel_data_type: ChannelType;
    
    public constructor(image_channel_order: ChannelOrder; image_channel_data_type: ChannelType);
    begin
      self.image_channel_order := image_channel_order;
      self.image_channel_data_type := image_channel_data_type;
    end;
    
  end;
  
  {$endregion Записи}
  
  {$region Другие типы}
  
  OpenCLException = sealed class(Exception)
    private ec: ErrorCode;
    public property Code: ErrorCode read ec;
    
    public constructor(Code: ErrorCode; Message: string);
    begin
      inherited Create(Message);
      self.ec := Code;
    end;
    
    public constructor(Code: ErrorCode) :=
    Create(Code, $'Ошибка OpenCL: {Code}');
    
  end;
  
  {$endregion Другие типы}
  
  {$region Функции}
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  cl = static class
    
    // added in cl1.0
    private static function z_BuildProgram_ovr_0(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clBuildProgram';
    private static function z_BuildProgram_ovr_0_anh0001000(&program: cl_program; num_devices: UInt32; device_list: IntPtr; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clBuildProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; device_list: array of cl_device_id; options: string; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (device_list<>nil) and (device_list.Length<>0) then
          Result := z_BuildProgram_ovr_0(&program, num_devices, device_list[0], par_4_str_ptr, pfn_notify, user_data) else
          Result := z_BuildProgram_ovr_0_anh0001000(&program, num_devices, IntPtr.Zero, par_4_str_ptr, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_BuildProgram_ovr_1_anh0001000(&program: cl_program; num_devices: UInt32; device_list: IntPtr; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clBuildProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; device_list: array of cl_device_id; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    if (device_list<>nil) and (device_list.Length<>0) then
      z_BuildProgram_ovr_0(&program, num_devices, device_list[0], options, pfn_notify, user_data) else
      z_BuildProgram_ovr_0_anh0001000(&program, num_devices, IntPtr.Zero, options, pfn_notify, user_data);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: string; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_BuildProgram_ovr_0(&program, num_devices, device_list, par_4_str_ptr, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    z_BuildProgram_ovr_0(&program, num_devices, device_list, options, pfn_notify, user_data);
    private static function z_BuildProgram_ovr_4(&program: cl_program; num_devices: UInt32; device_list: IntPtr; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clBuildProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; device_list: IntPtr; options: string; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_BuildProgram_ovr_4(&program, num_devices, device_list, par_4_str_ptr, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BuildProgram(&program: cl_program; num_devices: UInt32; device_list: IntPtr; options: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    z_BuildProgram_ovr_4(&program, num_devices, device_list, options, pfn_notify, user_data);
    
    // added in cl2.1
    private static function z_CloneKernel_ovr_0(source_kernel: cl_kernel; var errcode_ret: ErrorCode): cl_kernel;
    external 'opencl' name 'clCloneKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CloneKernel(source_kernel: cl_kernel; var errcode_ret: ErrorCode): cl_kernel :=
    z_CloneKernel_ovr_0(source_kernel, errcode_ret);
    
    // added in cl1.2
    private static function z_CompileProgram_ovr_0(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; var header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    private static function z_CompileProgram_ovr_0_anh0000000100(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: array of string; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_7_str_ptr: array of IntPtr;
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        par_7_str_ptr := header_include_names?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
        if (par_7_str_ptr<>nil) and (par_7_str_ptr.Length<>0) then
          Result := z_CompileProgram_ovr_0(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, par_7_str_ptr[0], pfn_notify, user_data) else
          Result := z_CompileProgram_ovr_0_anh0000000100(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, IntPtr.Zero, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
        foreach var arr_el1 in par_7_str_ptr do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CompileProgram_ovr_1_anh0000000100(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: array of IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (header_include_names<>nil) and (header_include_names.Length<>0) then
          Result := z_CompileProgram_ovr_0(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, header_include_names[0], pfn_notify, user_data) else
          Result := z_CompileProgram_ovr_0_anh0000000100(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, IntPtr.Zero, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_headers: UInt32; var input_headers: cl_program; var header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_CompileProgram_ovr_0(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, header_include_names, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_CompileProgram_ovr_3(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; input_headers: IntPtr; header_include_names: pointer; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_headers: UInt32; input_headers: IntPtr; header_include_names: pointer; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_CompileProgram_ovr_3(&program, num_devices, device_list, par_4_str_ptr, num_input_headers, input_headers, header_include_names, pfn_notify, user_data);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_CompileProgram_ovr_4_anh0000000100(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: array of string; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    begin
      var par_7_str_ptr: array of IntPtr;
      try
        par_7_str_ptr := header_include_names?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
        if (par_7_str_ptr<>nil) and (par_7_str_ptr.Length<>0) then
          Result := z_CompileProgram_ovr_0(&program, num_devices, device_list, options, num_input_headers, input_headers, par_7_str_ptr[0], pfn_notify, user_data) else
          Result := z_CompileProgram_ovr_0_anh0000000100(&program, num_devices, device_list, options, num_input_headers, input_headers, IntPtr.Zero, pfn_notify, user_data);
      finally
        foreach var arr_el1 in par_7_str_ptr do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CompileProgram_ovr_5_anh0000000100(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clCompileProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; header_include_names: array of IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    if (header_include_names<>nil) and (header_include_names.Length<>0) then
      z_CompileProgram_ovr_0(&program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names[0], pfn_notify, user_data) else
      z_CompileProgram_ovr_0_anh0000000100(&program, num_devices, device_list, options, num_input_headers, input_headers, IntPtr.Zero, pfn_notify, user_data);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; var input_headers: cl_program; var header_include_names: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    z_CompileProgram_ovr_0(&program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CompileProgram(&program: cl_program; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_headers: UInt32; input_headers: IntPtr; header_include_names: pointer; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    z_CompileProgram_ovr_3(&program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data);
    
    // added in cl1.0
    private static function z_CreateBuffer_ovr_0(context: cl_context; flags: MemFlags; size: UIntPtr; var host_ptr: Byte; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_CreateBuffer_ovr_0<T>(context: cl_context; flags: MemFlags; size: UIntPtr; var host_ptr: T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      Result := z_CreateBuffer_ovr_0(context, flags, size, PByte(pointer(@host_ptr))^, errcode_ret);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_CreateBuffer_ovr_0_anh000010(context: cl_context; flags: MemFlags; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBuffer_ovr_0(context, flags, size, PByte(nil)^, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBuffer<T>(context: cl_context; flags: MemFlags; size: UIntPtr; host_ptr: array of T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      if (host_ptr<>nil) and (host_ptr.Length<>0) then
        Result := temp_CreateBuffer_ovr_0(context, flags, size, host_ptr[0], errcode_ret) else
        Result := temp_CreateBuffer_ovr_0_anh000010(context, flags, size, errcode_ret);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBuffer<T>(context: cl_context; flags: MemFlags; size: UIntPtr; var host_ptr: T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      Result := z_CreateBuffer_ovr_0(context, flags, size, PByte(pointer(@host_ptr))^, errcode_ret);
    end;
    private static function z_CreateBuffer_ovr_2(context: cl_context; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBuffer(context: cl_context; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBuffer_ovr_2(context, flags, size, host_ptr, errcode_ret);
    
    // added in cl3.0
    private static function z_CreateBufferWithProperties_ovr_0(context: cl_context; var properties: MemProperties; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithProperties';
    private static function z_CreateBufferWithProperties_ovr_0_anh0010000(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateBufferWithProperties_ovr_0(context, properties[0], flags, size, host_ptr, errcode_ret) else
      z_CreateBufferWithProperties_ovr_0_anh0010000(context, IntPtr.Zero, flags, size, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBufferWithProperties_ovr_0(context, properties, flags, size, host_ptr, errcode_ret);
    private static function z_CreateBufferWithProperties_ovr_2(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBufferWithProperties_ovr_2(context, properties, flags, size, host_ptr, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateCommandQueue_ovr_0(context: cl_context; device: cl_device_id; properties: CommandQueueProperties; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueue';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueue(context: cl_context; device: cl_device_id; properties: CommandQueueProperties; var errcode_ret: ErrorCode): cl_command_queue :=
    z_CreateCommandQueue_ovr_0(context, device, properties, errcode_ret);
    
    // added in cl2.0
    private static function z_CreateCommandQueueWithProperties_ovr_0(context: cl_context; device: cl_device_id; var properties: QueueProperties; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithProperties';
    private static function z_CreateCommandQueueWithProperties_ovr_0_anh00010(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithProperties(context: cl_context; device: cl_device_id; properties: array of QueueProperties; var errcode_ret: ErrorCode): cl_command_queue :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateCommandQueueWithProperties_ovr_0(context, device, properties[0], errcode_ret) else
      z_CreateCommandQueueWithProperties_ovr_0_anh00010(context, device, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithProperties(context: cl_context; device: cl_device_id; var properties: QueueProperties; var errcode_ret: ErrorCode): cl_command_queue :=
    z_CreateCommandQueueWithProperties_ovr_0(context, device, properties, errcode_ret);
    private static function z_CreateCommandQueueWithProperties_ovr_2(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithProperties(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue :=
    z_CreateCommandQueueWithProperties_ovr_2(context, device, properties, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateContext_ovr_0(var properties: ContextProperties; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    private static function z_CreateContext_ovr_0_anh0100000(properties: IntPtr; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    private static function z_CreateContext_ovr_0_anh0001000(var properties: ContextProperties; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    private static function z_CreateContext_ovr_0_anh0101000(properties: IntPtr; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: array of ContextProperties; num_devices: UInt32; devices: array of cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (properties<>nil) and (properties.Length<>0) then
      if (devices<>nil) and (devices.Length<>0) then
        z_CreateContext_ovr_0(properties[0], num_devices, devices[0], pfn_notify, user_data, errcode_ret) else
        z_CreateContext_ovr_0_anh0001000(properties[0], num_devices, IntPtr.Zero, pfn_notify, user_data, errcode_ret) else
      if (devices<>nil) and (devices.Length<>0) then
        z_CreateContext_ovr_0_anh0100000(IntPtr.Zero, num_devices, devices[0], pfn_notify, user_data, errcode_ret) else
        z_CreateContext_ovr_0_anh0101000(IntPtr.Zero, num_devices, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    private static function z_CreateContext_ovr_1_anh0100000(properties: IntPtr; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: array of ContextProperties; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateContext_ovr_0(properties[0], num_devices, devices, pfn_notify, user_data, errcode_ret) else
      z_CreateContext_ovr_0_anh0100000(IntPtr.Zero, num_devices, devices, pfn_notify, user_data, errcode_ret);
    private static function z_CreateContext_ovr_2(var properties: ContextProperties; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    private static function z_CreateContext_ovr_2_anh0100000(properties: IntPtr; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: array of ContextProperties; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateContext_ovr_2(properties[0], num_devices, devices, pfn_notify, user_data, errcode_ret) else
      z_CreateContext_ovr_2_anh0100000(IntPtr.Zero, num_devices, devices, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(var properties: ContextProperties; num_devices: UInt32; devices: array of cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (devices<>nil) and (devices.Length<>0) then
      z_CreateContext_ovr_0(properties, num_devices, devices[0], pfn_notify, user_data, errcode_ret) else
      z_CreateContext_ovr_0_anh0001000(properties, num_devices, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(var properties: ContextProperties; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContext_ovr_0(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(var properties: ContextProperties; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContext_ovr_2(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
    private static function z_CreateContext_ovr_6(properties: IntPtr; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    private static function z_CreateContext_ovr_6_anh0001000(properties: IntPtr; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: IntPtr; num_devices: UInt32; devices: array of cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (devices<>nil) and (devices.Length<>0) then
      z_CreateContext_ovr_6(properties, num_devices, devices[0], pfn_notify, user_data, errcode_ret) else
      z_CreateContext_ovr_6_anh0001000(properties, num_devices, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: IntPtr; num_devices: UInt32; var devices: cl_device_id; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContext_ovr_6(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
    private static function z_CreateContext_ovr_8(properties: IntPtr; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(properties: IntPtr; num_devices: UInt32; devices: IntPtr; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContext_ovr_8(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateContextFromType_ovr_0(var properties: ContextProperties; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContextFromType';
    private static function z_CreateContextFromType_ovr_0_anh010000(properties: IntPtr; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContextFromType';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextFromType(properties: array of ContextProperties; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateContextFromType_ovr_0(properties[0], device_type, pfn_notify, user_data, errcode_ret) else
      z_CreateContextFromType_ovr_0_anh010000(IntPtr.Zero, device_type, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextFromType(var properties: ContextProperties; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContextFromType_ovr_0(properties, device_type, pfn_notify, user_data, errcode_ret);
    private static function z_CreateContextFromType_ovr_2(properties: IntPtr; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context;
    external 'opencl' name 'clCreateContextFromType';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextFromType(properties: IntPtr; device_type: DeviceType; pfn_notify: CreateContextCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_context :=
    z_CreateContextFromType_ovr_2(properties, device_type, pfn_notify, user_data, errcode_ret);
    
    // added in cl1.2
    private static function z_CreateImage_ovr_0(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; var host_ptr: Byte; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_CreateImage_ovr_0<T>(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; var host_ptr: T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      Result := z_CreateImage_ovr_0(context, flags, image_format, image_desc, PByte(pointer(@host_ptr))^, errcode_ret);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_CreateImage_ovr_0_anh0000010(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage_ovr_0(context, flags, image_format, image_desc, PByte(nil)^, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage<T>(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: array of T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      if (host_ptr<>nil) and (host_ptr.Length<>0) then
        Result := temp_CreateImage_ovr_0(context, flags, image_format, image_desc, host_ptr[0], errcode_ret) else
        Result := temp_CreateImage_ovr_0_anh0000010(context, flags, image_format, image_desc, errcode_ret);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage<T>(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; var host_ptr: T; var errcode_ret: ErrorCode): cl_mem; where T: record;
    begin
      Result := z_CreateImage_ovr_0(context, flags, image_format, image_desc, PByte(pointer(@host_ptr))^, errcode_ret);
    end;
    private static function z_CreateImage_ovr_2(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage(context: cl_context; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage_ovr_2(context, flags, image_format, image_desc, host_ptr, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateImage2D_ovr_0(context: cl_context; flags: MemFlags; var image_format: cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage2D';
    private static function z_CreateImage2D_ovr_0_anh000100000(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage2D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage2D(context: cl_context; flags: MemFlags; image_format: array of cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImage2D_ovr_0(context, flags, image_format[0], image_width, image_height, image_row_pitch, host_ptr, errcode_ret) else
      z_CreateImage2D_ovr_0_anh000100000(context, flags, IntPtr.Zero, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage2D(context: cl_context; flags: MemFlags; var image_format: cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage2D_ovr_0(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
    private static function z_CreateImage2D_ovr_2(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage2D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage2D(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_row_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage2D_ovr_2(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateImage3D_ovr_0(context: cl_context; flags: MemFlags; var image_format: cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage3D';
    private static function z_CreateImage3D_ovr_0_anh00010000000(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage3D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage3D(context: cl_context; flags: MemFlags; image_format: array of cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImage3D_ovr_0(context, flags, image_format[0], image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret) else
      z_CreateImage3D_ovr_0_anh00010000000(context, flags, IntPtr.Zero, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage3D(context: cl_context; flags: MemFlags; var image_format: cl_image_format; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage3D_ovr_0(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
    private static function z_CreateImage3D_ovr_2(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImage3D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImage3D(context: cl_context; flags: MemFlags; image_format: IntPtr; image_width: UIntPtr; image_height: UIntPtr; image_depth: UIntPtr; image_row_pitch: UIntPtr; image_slice_pitch: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImage3D_ovr_2(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
    
    // added in cl3.0
    private static function z_CreateImageWithProperties_ovr_0(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00001000(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00101000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00000100(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00100100(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00001100(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_0_anh00101100(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: array of cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      if (image_format<>nil) and (image_format.Length<>0) then
        if (image_desc<>nil) and (image_desc.Length<>0) then
          z_CreateImageWithProperties_ovr_0(context, properties[0], flags, image_format[0], image_desc[0], host_ptr, errcode_ret) else
          z_CreateImageWithProperties_ovr_0_anh00000100(context, properties[0], flags, image_format[0], IntPtr.Zero, host_ptr, errcode_ret) else
        if (image_desc<>nil) and (image_desc.Length<>0) then
          z_CreateImageWithProperties_ovr_0_anh00001000(context, properties[0], flags, IntPtr.Zero, image_desc[0], host_ptr, errcode_ret) else
          z_CreateImageWithProperties_ovr_0_anh00001100(context, properties[0], flags, IntPtr.Zero, IntPtr.Zero, host_ptr, errcode_ret) else
      if (image_format<>nil) and (image_format.Length<>0) then
        if (image_desc<>nil) and (image_desc.Length<>0) then
          z_CreateImageWithProperties_ovr_0_anh00100000(context, IntPtr.Zero, flags, image_format[0], image_desc[0], host_ptr, errcode_ret) else
          z_CreateImageWithProperties_ovr_0_anh00100100(context, IntPtr.Zero, flags, image_format[0], IntPtr.Zero, host_ptr, errcode_ret) else
        if (image_desc<>nil) and (image_desc.Length<>0) then
          z_CreateImageWithProperties_ovr_0_anh00101000(context, IntPtr.Zero, flags, IntPtr.Zero, image_desc[0], host_ptr, errcode_ret) else
          z_CreateImageWithProperties_ovr_0_anh00101100(context, IntPtr.Zero, flags, IntPtr.Zero, IntPtr.Zero, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_1_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_1_anh00001000(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_1_anh00101000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: array of cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      if (image_format<>nil) and (image_format.Length<>0) then
        z_CreateImageWithProperties_ovr_0(context, properties[0], flags, image_format[0], image_desc, host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00001000(context, properties[0], flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret) else
      if (image_format<>nil) and (image_format.Length<>0) then
        z_CreateImageWithProperties_ovr_0_anh00100000(context, IntPtr.Zero, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00101000(context, IntPtr.Zero, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_2(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_2_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_2_anh00001000(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_2_anh00101000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: array of cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      if (image_format<>nil) and (image_format.Length<>0) then
        z_CreateImageWithProperties_ovr_2(context, properties[0], flags, image_format[0], image_desc, host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_2_anh00001000(context, properties[0], flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret) else
      if (image_format<>nil) and (image_format.Length<>0) then
        z_CreateImageWithProperties_ovr_2_anh00100000(context, IntPtr.Zero, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_2_anh00101000(context, IntPtr.Zero, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_3_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_3_anh00100100(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_0(context, properties[0], flags, image_format, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00000100(context, properties[0], flags, image_format, IntPtr.Zero, host_ptr, errcode_ret) else
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_0_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00100100(context, IntPtr.Zero, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_4_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateImageWithProperties_ovr_0(context, properties[0], flags, image_format, image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_0_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_5_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateImageWithProperties_ovr_2(context, properties[0], flags, image_format, image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_2_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_6(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_6_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_6_anh00000100(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_6_anh00100100(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_6(context, properties[0], flags, image_format, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_6_anh00000100(context, properties[0], flags, image_format, IntPtr.Zero, host_ptr, errcode_ret) else
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_6_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_6_anh00100100(context, IntPtr.Zero, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_7_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateImageWithProperties_ovr_6(context, properties[0], flags, image_format, image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_6_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_8(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_8_anh00100000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: array of MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateImageWithProperties_ovr_8(context, properties[0], flags, image_format, image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_8_anh00100000(context, IntPtr.Zero, flags, image_format, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: array of cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_0(context, properties, flags, image_format[0], image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00000100(context, properties, flags, image_format[0], IntPtr.Zero, host_ptr, errcode_ret) else
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_0_anh00001000(context, properties, flags, IntPtr.Zero, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_0_anh00001100(context, properties, flags, IntPtr.Zero, IntPtr.Zero, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: array of cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImageWithProperties_ovr_0(context, properties, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_0_anh00001000(context, properties, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: array of cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImageWithProperties_ovr_2(context, properties, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_2_anh00001000(context, properties, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_desc<>nil) and (image_desc.Length<>0) then
      z_CreateImageWithProperties_ovr_0(context, properties, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_0_anh00000100(context, properties, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_0(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_2(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_desc<>nil) and (image_desc.Length<>0) then
      z_CreateImageWithProperties_ovr_6(context, properties, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_6_anh00000100(context, properties, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_6(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; var properties: MemProperties; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_8(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_18(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_18_anh00001000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_18_anh00000100(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_18_anh00001100(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: array of cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_18(context, properties, flags, image_format[0], image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_18_anh00000100(context, properties, flags, image_format[0], IntPtr.Zero, host_ptr, errcode_ret) else
      if (image_desc<>nil) and (image_desc.Length<>0) then
        z_CreateImageWithProperties_ovr_18_anh00001000(context, properties, flags, IntPtr.Zero, image_desc[0], host_ptr, errcode_ret) else
        z_CreateImageWithProperties_ovr_18_anh00001100(context, properties, flags, IntPtr.Zero, IntPtr.Zero, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_19_anh00001000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: array of cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImageWithProperties_ovr_18(context, properties, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_18_anh00001000(context, properties, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_20(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_20_anh00001000(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: array of cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_CreateImageWithProperties_ovr_20(context, properties, flags, image_format[0], image_desc, host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_20_anh00001000(context, properties, flags, IntPtr.Zero, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_desc<>nil) and (image_desc.Length<>0) then
      z_CreateImageWithProperties_ovr_18(context, properties, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_18_anh00000100(context, properties, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_18(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; var image_format: cl_image_format; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_20(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_24(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    private static function z_CreateImageWithProperties_ovr_24_anh00000100(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: array of cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (image_desc<>nil) and (image_desc.Length<>0) then
      z_CreateImageWithProperties_ovr_24(context, properties, flags, image_format, image_desc[0], host_ptr, errcode_ret) else
      z_CreateImageWithProperties_ovr_24_anh00000100(context, properties, flags, image_format, IntPtr.Zero, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; var image_desc: cl_image_desc; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_24(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    private static function z_CreateImageWithProperties_ovr_26(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateImageWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageWithProperties(context: cl_context; properties: IntPtr; flags: MemFlags; image_format: IntPtr; image_desc: IntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateImageWithProperties_ovr_26(context, properties, flags, image_format, image_desc, host_ptr, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateKernel_ovr_0(&program: cl_program; kernel_name: IntPtr; var errcode_ret: ErrorCode): cl_kernel;
    external 'opencl' name 'clCreateKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernel(&program: cl_program; kernel_name: string; var errcode_ret: ErrorCode): cl_kernel;
    begin
      var par_2_str_ptr: IntPtr;
      try
        par_2_str_ptr := Marshal.StringToHGlobalAnsi(kernel_name);
        Result := z_CreateKernel_ovr_0(&program, par_2_str_ptr, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_2_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernel(&program: cl_program; kernel_name: IntPtr; var errcode_ret: ErrorCode): cl_kernel :=
    z_CreateKernel_ovr_0(&program, kernel_name, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateKernelsInProgram_ovr_0(&program: cl_program; num_kernels: UInt32; var kernels: cl_kernel; var num_kernels_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateKernelsInProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernelsInProgram(&program: cl_program; num_kernels: UInt32; var kernels: cl_kernel; var num_kernels_ret: UInt32): ErrorCode :=
    z_CreateKernelsInProgram_ovr_0(&program, num_kernels, kernels, num_kernels_ret);
    private static function z_CreateKernelsInProgram_ovr_1(&program: cl_program; num_kernels: UInt32; var kernels: cl_kernel; num_kernels_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateKernelsInProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernelsInProgram(&program: cl_program; num_kernels: UInt32; var kernels: cl_kernel; num_kernels_ret: IntPtr): ErrorCode :=
    z_CreateKernelsInProgram_ovr_1(&program, num_kernels, kernels, num_kernels_ret);
    private static function z_CreateKernelsInProgram_ovr_2(&program: cl_program; num_kernels: UInt32; kernels: IntPtr; var num_kernels_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateKernelsInProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernelsInProgram(&program: cl_program; num_kernels: UInt32; kernels: IntPtr; var num_kernels_ret: UInt32): ErrorCode :=
    z_CreateKernelsInProgram_ovr_2(&program, num_kernels, kernels, num_kernels_ret);
    private static function z_CreateKernelsInProgram_ovr_3(&program: cl_program; num_kernels: UInt32; kernels: IntPtr; num_kernels_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateKernelsInProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateKernelsInProgram(&program: cl_program; num_kernels: UInt32; kernels: IntPtr; num_kernels_ret: IntPtr): ErrorCode :=
    z_CreateKernelsInProgram_ovr_3(&program, num_kernels, kernels, num_kernels_ret);
    
    // added in cl2.0
    private static function z_CreatePipe_ovr_0(context: cl_context; flags: MemFlags; pipe_packet_size: UInt32; pipe_max_packets: UInt32; properties: pointer; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreatePipe';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePipe(context: cl_context; flags: MemFlags; pipe_packet_size: UInt32; pipe_max_packets: UInt32; properties: pointer; var errcode_ret: ErrorCode): cl_mem :=
    z_CreatePipe_ovr_0(context, flags, pipe_packet_size, pipe_max_packets, properties, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateProgramWithBinary_ovr_0(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; var binaries: IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    private static function z_CreateProgramWithBinary_ovr_0_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of array of Byte; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_5_temp_arr1: array of IntPtr;
      try
        par_5_temp_arr1 := binaries?.ConvertAll(arr_el1->begin
          if (arr_el1=nil) or (arr_el1.Length=0) then
            Result := IntPtr.Zero else
          begin
            var l := Marshal.SizeOf&<Byte>*arr_el1.Length;
            Result := Marshal.AllocHGlobal(l);
            Marshal.Copy(arr_el1,0,Result,l);
          end;
        end);
        if (par_5_temp_arr1<>nil) and (par_5_temp_arr1.Length<>0) then
          Result := z_CreateProgramWithBinary_ovr_0(context, num_devices, device_list, lengths, par_5_temp_arr1[0], binary_status, errcode_ret) else
          Result := z_CreateProgramWithBinary_ovr_0_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
      finally
        if par_5_temp_arr1<>nil then foreach var arr_el1 in par_5_temp_arr1 do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CreateProgramWithBinary_ovr_1(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; var binaries: IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    private static function z_CreateProgramWithBinary_ovr_1_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of array of Byte; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program;
    begin
      var par_5_temp_arr1: array of IntPtr;
      try
        par_5_temp_arr1 := binaries?.ConvertAll(arr_el1->begin
          if (arr_el1=nil) or (arr_el1.Length=0) then
            Result := IntPtr.Zero else
          begin
            var l := Marshal.SizeOf&<Byte>*arr_el1.Length;
            Result := Marshal.AllocHGlobal(l);
            Marshal.Copy(arr_el1,0,Result,l);
          end;
        end);
        if (par_5_temp_arr1<>nil) and (par_5_temp_arr1.Length<>0) then
          Result := z_CreateProgramWithBinary_ovr_1(context, num_devices, device_list, lengths, par_5_temp_arr1[0], binary_status, errcode_ret) else
          Result := z_CreateProgramWithBinary_ovr_1_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
      finally
        if par_5_temp_arr1<>nil then foreach var arr_el1 in par_5_temp_arr1 do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CreateProgramWithBinary_ovr_2(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; var binaries: IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    private static function z_CreateProgramWithBinary_ovr_2_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of array of Byte; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_5_temp_arr1: array of IntPtr;
      try
        par_5_temp_arr1 := binaries?.ConvertAll(arr_el1->begin
          if (arr_el1=nil) or (arr_el1.Length=0) then
            Result := IntPtr.Zero else
          begin
            var l := Marshal.SizeOf&<Byte>*arr_el1.Length;
            Result := Marshal.AllocHGlobal(l);
            Marshal.Copy(arr_el1,0,Result,l);
          end;
        end);
        if (par_5_temp_arr1<>nil) and (par_5_temp_arr1.Length<>0) then
          Result := z_CreateProgramWithBinary_ovr_2(context, num_devices, device_list, lengths, par_5_temp_arr1[0], binary_status, errcode_ret) else
          Result := z_CreateProgramWithBinary_ovr_2_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
      finally
        if par_5_temp_arr1<>nil then foreach var arr_el1 in par_5_temp_arr1 do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CreateProgramWithBinary_ovr_3_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program :=
    if (binaries<>nil) and (binaries.Length<>0) then
      z_CreateProgramWithBinary_ovr_0(context, num_devices, device_list, lengths, binaries[0], binary_status, errcode_ret) else
      z_CreateProgramWithBinary_ovr_0_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
    private static function z_CreateProgramWithBinary_ovr_4_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program :=
    if (binaries<>nil) and (binaries.Length<>0) then
      z_CreateProgramWithBinary_ovr_1(context, num_devices, device_list, lengths, binaries[0], binary_status, errcode_ret) else
      z_CreateProgramWithBinary_ovr_1_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
    private static function z_CreateProgramWithBinary_ovr_5_anh00000100(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: array of IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (binaries<>nil) and (binaries.Length<>0) then
      z_CreateProgramWithBinary_ovr_2(context, num_devices, device_list, lengths, binaries[0], binary_status, errcode_ret) else
      z_CreateProgramWithBinary_ovr_2_anh00000100(context, num_devices, device_list, lengths, IntPtr.Zero, binary_status, errcode_ret);
    private static function z_CreateProgramWithBinary_ovr_6(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithBinary_ovr_6(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
    private static function z_CreateProgramWithBinary_ovr_7(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; var binary_status: ErrorCode; errcode_ret: IntPtr): cl_program :=
    z_CreateProgramWithBinary_ovr_7(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
    private static function z_CreateProgramWithBinary_ovr_8(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBinary';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBinary(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; var lengths: UIntPtr; binaries: IntPtr; binary_status: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithBinary_ovr_8(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
    
    // added in cl1.2
    private static function z_CreateProgramWithBuiltInKernels_ovr_0(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBuiltInKernels';
    private static function z_CreateProgramWithBuiltInKernels_ovr_0_anh000100(context: cl_context; num_devices: UInt32; device_list: IntPtr; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBuiltInKernels';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; kernel_names: string; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(kernel_names);
        if (device_list<>nil) and (device_list.Length<>0) then
          Result := z_CreateProgramWithBuiltInKernels_ovr_0(context, num_devices, device_list[0], par_4_str_ptr, errcode_ret) else
          Result := z_CreateProgramWithBuiltInKernels_ovr_0_anh000100(context, num_devices, IntPtr.Zero, par_4_str_ptr, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_CreateProgramWithBuiltInKernels_ovr_1_anh000100(context: cl_context; num_devices: UInt32; device_list: IntPtr; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBuiltInKernels';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (device_list<>nil) and (device_list.Length<>0) then
      z_CreateProgramWithBuiltInKernels_ovr_0(context, num_devices, device_list[0], kernel_names, errcode_ret) else
      z_CreateProgramWithBuiltInKernels_ovr_0_anh000100(context, num_devices, IntPtr.Zero, kernel_names, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; kernel_names: string; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(kernel_names);
        Result := z_CreateProgramWithBuiltInKernels_ovr_0(context, num_devices, device_list, par_4_str_ptr, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithBuiltInKernels_ovr_0(context, num_devices, device_list, kernel_names, errcode_ret);
    private static function z_CreateProgramWithBuiltInKernels_ovr_4(context: cl_context; num_devices: UInt32; device_list: IntPtr; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithBuiltInKernels';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; device_list: IntPtr; kernel_names: string; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(kernel_names);
        Result := z_CreateProgramWithBuiltInKernels_ovr_4(context, num_devices, device_list, par_4_str_ptr, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithBuiltInKernels(context: cl_context; num_devices: UInt32; device_list: IntPtr; kernel_names: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithBuiltInKernels_ovr_4(context, num_devices, device_list, kernel_names, errcode_ret);
    
    // added in cl2.1
    private static function z_CreateProgramWithIL_ovr_0(context: cl_context; il: IntPtr; length: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithIL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithIL(context: cl_context; il: IntPtr; length: UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithIL_ovr_0(context, il, length, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateProgramWithSource_ovr_0(context: cl_context; count: UInt32; var strings: IntPtr; var lengths: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    private static function z_CreateProgramWithSource_ovr_0_anh000100(context: cl_context; count: UInt32; strings: IntPtr; var lengths: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    private static function z_CreateProgramWithSource_ovr_0_anh000010(context: cl_context; count: UInt32; var strings: IntPtr; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    private static function z_CreateProgramWithSource_ovr_0_anh000110(context: cl_context; count: UInt32; strings: IntPtr; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithSource(context: cl_context; count: UInt32; strings: array of string; lengths: array of UIntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_3_str_ptr: array of IntPtr;
      try
        par_3_str_ptr := strings?.ConvertAll(arr_el1->Marshal.StringToHGlobalAnsi(arr_el1));
        if (par_3_str_ptr<>nil) and (par_3_str_ptr.Length<>0) then
          if (lengths<>nil) and (lengths.Length<>0) then
            Result := z_CreateProgramWithSource_ovr_0(context, count, par_3_str_ptr[0], lengths[0], errcode_ret) else
            Result := z_CreateProgramWithSource_ovr_0_anh000010(context, count, par_3_str_ptr[0], IntPtr.Zero, errcode_ret) else
          if (lengths<>nil) and (lengths.Length<>0) then
            Result := z_CreateProgramWithSource_ovr_0_anh000100(context, count, IntPtr.Zero, lengths[0], errcode_ret) else
            Result := z_CreateProgramWithSource_ovr_0_anh000110(context, count, IntPtr.Zero, IntPtr.Zero, errcode_ret);
      finally
        foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
      end;
    end;
    private static function z_CreateProgramWithSource_ovr_1_anh000100(context: cl_context; count: UInt32; strings: IntPtr; var lengths: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    private static function z_CreateProgramWithSource_ovr_1_anh000010(context: cl_context; count: UInt32; var strings: IntPtr; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    private static function z_CreateProgramWithSource_ovr_1_anh000110(context: cl_context; count: UInt32; strings: IntPtr; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithSource(context: cl_context; count: UInt32; strings: array of IntPtr; lengths: array of UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (strings<>nil) and (strings.Length<>0) then
      if (lengths<>nil) and (lengths.Length<>0) then
        z_CreateProgramWithSource_ovr_0(context, count, strings[0], lengths[0], errcode_ret) else
        z_CreateProgramWithSource_ovr_0_anh000010(context, count, strings[0], IntPtr.Zero, errcode_ret) else
      if (lengths<>nil) and (lengths.Length<>0) then
        z_CreateProgramWithSource_ovr_0_anh000100(context, count, IntPtr.Zero, lengths[0], errcode_ret) else
        z_CreateProgramWithSource_ovr_0_anh000110(context, count, IntPtr.Zero, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithSource(context: cl_context; count: UInt32; var strings: IntPtr; var lengths: UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithSource_ovr_0(context, count, strings, lengths, errcode_ret);
    private static function z_CreateProgramWithSource_ovr_3(context: cl_context; count: UInt32; strings: pointer; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithSource';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithSource(context: cl_context; count: UInt32; strings: pointer; lengths: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithSource_ovr_3(context, count, strings, lengths, errcode_ret);
    
    // added in cl1.0
    private static function z_CreateSampler_ovr_0(context: cl_context; normalized_coords: Bool; addressing_mode: AddressingMode; filter_mode: FilterMode; var errcode_ret: ErrorCode): cl_sampler;
    external 'opencl' name 'clCreateSampler';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSampler(context: cl_context; normalized_coords: Bool; addressing_mode: AddressingMode; filter_mode: FilterMode; var errcode_ret: ErrorCode): cl_sampler :=
    z_CreateSampler_ovr_0(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
    
    // added in cl2.0
    private static function z_CreateSamplerWithProperties_ovr_0(context: cl_context; var sampler_properties: SamplerProperties; var errcode_ret: ErrorCode): cl_sampler;
    external 'opencl' name 'clCreateSamplerWithProperties';
    private static function z_CreateSamplerWithProperties_ovr_0_anh0010(context: cl_context; sampler_properties: IntPtr; var errcode_ret: ErrorCode): cl_sampler;
    external 'opencl' name 'clCreateSamplerWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSamplerWithProperties(context: cl_context; sampler_properties: array of SamplerProperties; var errcode_ret: ErrorCode): cl_sampler :=
    if (sampler_properties<>nil) and (sampler_properties.Length<>0) then
      z_CreateSamplerWithProperties_ovr_0(context, sampler_properties[0], errcode_ret) else
      z_CreateSamplerWithProperties_ovr_0_anh0010(context, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSamplerWithProperties(context: cl_context; var sampler_properties: SamplerProperties; var errcode_ret: ErrorCode): cl_sampler :=
    z_CreateSamplerWithProperties_ovr_0(context, sampler_properties, errcode_ret);
    private static function z_CreateSamplerWithProperties_ovr_2(context: cl_context; sampler_properties: IntPtr; var errcode_ret: ErrorCode): cl_sampler;
    external 'opencl' name 'clCreateSamplerWithProperties';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSamplerWithProperties(context: cl_context; sampler_properties: IntPtr; var errcode_ret: ErrorCode): cl_sampler :=
    z_CreateSamplerWithProperties_ovr_2(context, sampler_properties, errcode_ret);
    
    // added in cl1.1
    private static function z_CreateSubBuffer_ovr_0(buffer: cl_mem; flags: MemFlags; buffer_create_type: BufferCreateType; var buffer_create_info: cl_buffer_region; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateSubBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubBuffer(buffer: cl_mem; flags: MemFlags; buffer_create_type: BufferCreateType; var buffer_create_info: cl_buffer_region; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateSubBuffer_ovr_0(buffer, flags, buffer_create_type, buffer_create_info, errcode_ret);
    private static function z_CreateSubBuffer_ovr_1(buffer: cl_mem; flags: MemFlags; buffer_create_type: BufferCreateType; buffer_create_info: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateSubBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubBuffer(buffer: cl_mem; flags: MemFlags; buffer_create_type: BufferCreateType; buffer_create_info: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateSubBuffer_ovr_1(buffer, flags, buffer_create_type, buffer_create_info, errcode_ret);
    
    // added in cl1.2
    private static function z_CreateSubDevices_ovr_0(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    private static function z_CreateSubDevices_ovr_0_anh001000(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: array of DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevices_ovr_0(in_device, properties[0], num_devices, out_devices, num_devices_ret) else
      z_CreateSubDevices_ovr_0_anh001000(in_device, IntPtr.Zero, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_1(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    private static function z_CreateSubDevices_ovr_1_anh001000(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: array of DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevices_ovr_1(in_device, properties[0], num_devices, out_devices, num_devices_ret) else
      z_CreateSubDevices_ovr_1_anh001000(in_device, IntPtr.Zero, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_2(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    private static function z_CreateSubDevices_ovr_2_anh001000(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: array of DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevices_ovr_2(in_device, properties[0], num_devices, out_devices, num_devices_ret) else
      z_CreateSubDevices_ovr_2_anh001000(in_device, IntPtr.Zero, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_3(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    private static function z_CreateSubDevices_ovr_3_anh001000(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: array of DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevices_ovr_3(in_device, properties[0], num_devices, out_devices, num_devices_ret) else
      z_CreateSubDevices_ovr_3_anh001000(in_device, IntPtr.Zero, num_devices, out_devices, num_devices_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode :=
    z_CreateSubDevices_ovr_0(in_device, properties, num_devices, out_devices, num_devices_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode :=
    z_CreateSubDevices_ovr_1(in_device, properties, num_devices, out_devices, num_devices_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode :=
    z_CreateSubDevices_ovr_2(in_device, properties, num_devices, out_devices, num_devices_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; var properties: DevicePartitionProperty; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode :=
    z_CreateSubDevices_ovr_3(in_device, properties, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_8(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; var num_devices_ret: UInt32): ErrorCode :=
    z_CreateSubDevices_ovr_8(in_device, properties, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_9(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; var out_devices: cl_device_id; num_devices_ret: IntPtr): ErrorCode :=
    z_CreateSubDevices_ovr_9(in_device, properties, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_10(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; var num_devices_ret: UInt32): ErrorCode :=
    z_CreateSubDevices_ovr_10(in_device, properties, num_devices, out_devices, num_devices_ret);
    private static function z_CreateSubDevices_ovr_11(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevices';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevices(in_device: cl_device_id; properties: IntPtr; num_devices: UInt32; out_devices: IntPtr; num_devices_ret: IntPtr): ErrorCode :=
    z_CreateSubDevices_ovr_11(in_device, properties, num_devices, out_devices, num_devices_ret);
    
    // added in cl1.1
    private static function z_CreateUserEvent_ovr_0(context: cl_context; var errcode_ret: ErrorCode): cl_event;
    external 'opencl' name 'clCreateUserEvent';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateUserEvent(context: cl_context; var errcode_ret: ErrorCode): cl_event :=
    z_CreateUserEvent_ovr_0(context, errcode_ret);
    
    // added in cl1.0
    private static function z_EnqueueBarrier_ovr_0(command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clEnqueueBarrier';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrier(command_queue: cl_command_queue): ErrorCode :=
    z_EnqueueBarrier_ovr_0(command_queue);
    
    // added in cl1.2
    private static function z_EnqueueBarrierWithWaitList_ovr_0(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    private static function z_EnqueueBarrierWithWaitList_ovr_0_anh00010(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueBarrierWithWaitList_ovr_0(command_queue, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueBarrierWithWaitList_ovr_0_anh00010(command_queue, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueBarrierWithWaitList_ovr_1(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    private static function z_EnqueueBarrierWithWaitList_ovr_1_anh00010(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueBarrierWithWaitList_ovr_1(command_queue, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueBarrierWithWaitList_ovr_1_anh00010(command_queue, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueBarrierWithWaitList_ovr_0(command_queue, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueBarrierWithWaitList_ovr_1(command_queue, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueBarrierWithWaitList_ovr_4(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueBarrierWithWaitList_ovr_4(command_queue, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueBarrierWithWaitList_ovr_5(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueBarrierWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueBarrierWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueBarrierWithWaitList_ovr_5(command_queue, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueCopyBuffer_ovr_0(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    private static function z_EnqueueCopyBuffer_ovr_0_anh0000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBuffer_ovr_0(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBuffer_ovr_0_anh0000000010(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyBuffer_ovr_1(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    private static function z_EnqueueCopyBuffer_ovr_1_anh0000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBuffer_ovr_1(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBuffer_ovr_1_anh0000000010(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBuffer_ovr_0(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBuffer_ovr_1(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBuffer_ovr_4(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBuffer_ovr_4(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBuffer_ovr_5(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBuffer(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBuffer_ovr_5(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.1
    private static function z_EnqueueCopyBufferRect_ovr_0(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000100000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001100000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000010000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001010000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00000110000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_0_anh00001110000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00000000000010(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00000010000010(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00000100000010(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00000110000010(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00001000000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00001010000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00001100000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_0_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_0_anh00001110000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyBufferRect_ovr_1(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000100000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001100000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000010000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001010000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00000110000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_1_anh00001110000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00000000000010(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00000010000010(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00000100000010(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00000110000010(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00001000000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00001010000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00001100000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyBufferRect_ovr_1_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyBufferRect_ovr_1_anh00001110000010(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_2_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_0(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_0_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_0_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_0_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_0_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_0_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_0_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_0_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_3_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_1(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_1_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_1_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_1_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_1_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_1_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_1_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_1_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferRect_ovr_4(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_4_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_4(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_4_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_4_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_4_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_4_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_4_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_4_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_4_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferRect_ovr_5(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00001000000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00000100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00001100000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00000010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00001010000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00000110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    private static function z_EnqueueCopyBufferRect_ovr_5_anh00001110000000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_5(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_5_anh00000010000000(command_queue, src_buffer, dst_buffer, src_origin[0], dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_5_anh00000100000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_5_anh00000110000000(command_queue, src_buffer, dst_buffer, src_origin[0], IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_5_anh00001000000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_5_anh00001010000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, dst_origin[0], IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyBufferRect_ovr_5_anh00001100000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, region[0], src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyBufferRect_ovr_5_anh00001110000000(command_queue, src_buffer, dst_buffer, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBufferRect_ovr_0(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBufferRect_ovr_0_anh00000000000010(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBufferRect_ovr_1(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBufferRect_ovr_1_anh00000000000010(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBufferRect_ovr_0(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBufferRect_ovr_1(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBufferRect_ovr_4(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferRect(command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBufferRect_ovr_5(command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueCopyBufferToImage_ovr_0(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000010010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000001010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_0_anh0000011010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_0(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_0_anh0000000010(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_0_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_0_anh0000001010(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_0_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_0_anh0000010010(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_0_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_0_anh0000011010(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyBufferToImage_ovr_1(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000000010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000010010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000001010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_1_anh0000011010(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_1(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_1_anh0000000010(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_1_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_1_anh0000001010(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_1_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_1_anh0000010010(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyBufferToImage_ovr_1_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyBufferToImage_ovr_1_anh0000011010(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyBufferToImage_ovr_2_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_2_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_2_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_0(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_0_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_0_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_0_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferToImage_ovr_3_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_3_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_3_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_1(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_1_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_1_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_1_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferToImage_ovr_4(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_4_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_4_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_4_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_4(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_4_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_4_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_4_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyBufferToImage_ovr_5(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_5_anh0000010000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_5_anh0000001000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    private static function z_EnqueueCopyBufferToImage_ovr_5_anh0000011000(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyBufferToImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (dst_origin<>nil) and (dst_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_5(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_5_anh0000001000(command_queue, src_buffer, dst_image, src_offset, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyBufferToImage_ovr_5_anh0000010000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyBufferToImage_ovr_5_anh0000011000(command_queue, src_buffer, dst_image, src_offset, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBufferToImage_ovr_0(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBufferToImage_ovr_0_anh0000000010(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyBufferToImage_ovr_1(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyBufferToImage_ovr_1_anh0000000010(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBufferToImage_ovr_0(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBufferToImage_ovr_1(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyBufferToImage_ovr_4(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyBufferToImage(command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyBufferToImage_ovr_5(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueCopyImage_ovr_0(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000100010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000110010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000101010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000011010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_0_anh0000111010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000000010(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000001010(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000010010(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000011010(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000100010(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000101010(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000110010(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_0_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_0_anh0000111010(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyImage_ovr_1(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000100010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000110010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000101010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000011010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_1_anh0000111010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000000010(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000001010(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000010010(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000011010(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000100010(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000101010(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (region<>nil) and (region.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000110010(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueCopyImage_ovr_1_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueCopyImage_ovr_1_anh0000111010(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyImage_ovr_2_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_2_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_0(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_0_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_0_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_0_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_0_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_0_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_0_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_0_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImage_ovr_3_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_3_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_1(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_1_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_1_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_1_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_1_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_1_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_1_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_1_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImage_ovr_4(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_4_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_4(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_4_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_4_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_4_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_4_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_4_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_4_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_4_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImage_ovr_5(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000101000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; var dst_origin: UIntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    private static function z_EnqueueCopyImage_ovr_5_anh0000111000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: array of UIntPtr; dst_origin: array of UIntPtr; region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_5(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_5_anh0000001000(command_queue, src_image, dst_image, src_origin[0], dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_5_anh0000010000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_5_anh0000011000(command_queue, src_image, dst_image, src_origin[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (dst_origin<>nil) and (dst_origin.Length<>0) then
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_5_anh0000100000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_5_anh0000101000(command_queue, src_image, dst_image, IntPtr.Zero, dst_origin[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (region<>nil) and (region.Length<>0) then
          z_EnqueueCopyImage_ovr_5_anh0000110000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, region[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueCopyImage_ovr_5_anh0000111000(command_queue, src_image, dst_image, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyImage_ovr_0(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyImage_ovr_0_anh0000000010(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyImage_ovr_1(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyImage_ovr_1_anh0000000010(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyImage_ovr_0(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyImage_ovr_1(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyImage_ovr_4(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImage(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyImage_ovr_5(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueCopyImageToBuffer_ovr_0(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000100010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_0_anh0000110010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_0(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000000010(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000010010(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000100010(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_0_anh0000110010(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyImageToBuffer_ovr_1(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000100010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_1_anh0000110010(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_1(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000000010(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000010010(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000100010(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueCopyImageToBuffer_ovr_1_anh0000110010(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCopyImageToBuffer_ovr_2_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_2_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_2_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_0(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_0_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_0_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_0_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImageToBuffer_ovr_3_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_3_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_3_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_1(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_1_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_1_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_1_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImageToBuffer_ovr_4(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_4_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_4_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_4_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_4(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_4_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_4_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_4_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCopyImageToBuffer_ovr_5(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_5_anh0000100000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_5_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    private static function z_EnqueueCopyImageToBuffer_ovr_5_anh0000110000(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCopyImageToBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: array of UIntPtr; region: array of UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (src_origin<>nil) and (src_origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_5(command_queue, src_image, dst_buffer, src_origin[0], region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_5_anh0000010000(command_queue, src_image, dst_buffer, src_origin[0], IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueCopyImageToBuffer_ovr_5_anh0000100000(command_queue, src_image, dst_buffer, IntPtr.Zero, region[0], dst_offset, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueCopyImageToBuffer_ovr_5_anh0000110000(command_queue, src_image, dst_buffer, IntPtr.Zero, IntPtr.Zero, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyImageToBuffer_ovr_0(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyImageToBuffer_ovr_0_anh0000000010(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCopyImageToBuffer_ovr_1(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCopyImageToBuffer_ovr_1_anh0000000010(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyImageToBuffer_ovr_0(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyImageToBuffer_ovr_1(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCopyImageToBuffer_ovr_4(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCopyImageToBuffer(command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCopyImageToBuffer_ovr_5(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.2
    private static function z_EnqueueFillBuffer_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private static function z_EnqueueFillBuffer_ovr_0_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_0<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueFillBuffer_ovr_0_anh0000000010(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_0_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueFillBuffer_ovr_0_anh0000000010(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_0(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_0_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillBuffer_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private static function z_EnqueueFillBuffer_ovr_1_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_1<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueFillBuffer_ovr_1_anh0000000010(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_1_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueFillBuffer_ovr_1_anh0000000010(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_1(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_1_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_2<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_2_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_2(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_2_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_3<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_3_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_3(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_3_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillBuffer_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_4<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_4(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_4_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueFillBuffer_ovr_4(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_4(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_4_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillBuffer_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; var pattern: Byte; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_5<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_5(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueFillBuffer_ovr_5_anh0001000000(command_queue: cl_command_queue; buffer: cl_mem; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueFillBuffer_ovr_5(command_queue, buffer, PByte(nil)^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; pattern: array of T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueFillBuffer_ovr_5(command_queue, buffer, pattern[0], pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueFillBuffer_ovr_5_anh0001000000(command_queue, buffer, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueFillBuffer_ovr_0_anh0000000010(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueFillBuffer_ovr_1_anh0000000010(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_0(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_1(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_4(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; var pattern: T; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillBuffer_ovr_5(command_queue, buffer, PByte(pointer(@pattern))^, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillBuffer_ovr_12(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private static function z_EnqueueFillBuffer_ovr_12_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueFillBuffer_ovr_12(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueFillBuffer_ovr_12_anh0000000010(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueFillBuffer_ovr_13(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    private static function z_EnqueueFillBuffer_ovr_13_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueFillBuffer_ovr_13(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueFillBuffer_ovr_13_anh0000000010(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueFillBuffer_ovr_12(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueFillBuffer_ovr_13(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueFillBuffer_ovr_16(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueFillBuffer_ovr_16(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueFillBuffer_ovr_17(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillBuffer(command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueFillBuffer_ovr_17(command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.2
    private static function z_EnqueueFillImage_ovr_0(command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage<T>(command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillImage_ovr_0(command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillImage_ovr_1(command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage<T>(command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillImage_ovr_1(command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillImage_ovr_2(command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage<T>(command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillImage_ovr_2(command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillImage_ovr_3(command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage<T>(command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueFillImage_ovr_3(command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueFillImage_ovr_4(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueFillImage_ovr_4(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueFillImage_ovr_5(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueFillImage_ovr_5(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueFillImage_ovr_6(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueFillImage_ovr_6(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueFillImage_ovr_7(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueFillImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueFillImage(command_queue: cl_command_queue; image: cl_mem; fill_color: IntPtr; var origin: UIntPtr; var region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueFillImage_ovr_7(command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueMapBuffer_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    private static function z_EnqueueMapBuffer_ovr_0_anh00000000100(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMapBuffer_ovr_0(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
      z_EnqueueMapBuffer_ovr_0_anh00000000100(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    private static function z_EnqueueMapBuffer_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    private static function z_EnqueueMapBuffer_ovr_1_anh00000000100(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMapBuffer_ovr_1(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
      z_EnqueueMapBuffer_ovr_1_anh00000000100(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapBuffer_ovr_0(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapBuffer_ovr_1(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    private static function z_EnqueueMapBuffer_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapBuffer_ovr_4(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    private static function z_EnqueueMapBuffer_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_map: Bool; map_flags: MapFlags; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapBuffer_ovr_5(command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    
    // added in cl1.0
    private static function z_EnqueueMapImage_ovr_0(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000000000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000010000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000001000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_0_anh0000011000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_0(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_0_anh0000000000100(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_0_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_0_anh0000001000100(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_0_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_0_anh0000010000100(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_0_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_0_anh0000011000100(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    private static function z_EnqueueMapImage_ovr_1(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000000000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000010000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000001000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_1_anh0000011000100(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_1(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_1_anh0000000000100(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_1_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_1_anh0000001000100(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_1_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_1_anh0000010000100(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueMapImage_ovr_1_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
          z_EnqueueMapImage_ovr_1_anh0000011000100(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    private static function z_EnqueueMapImage_ovr_2_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_2_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_2_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_0(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_0_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_0_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_0_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    private static function z_EnqueueMapImage_ovr_3_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_3_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_3_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_1(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_1_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_1_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_1_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    private static function z_EnqueueMapImage_ovr_4(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_4_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_4_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_4_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_4(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_4_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_4_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_4_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    private static function z_EnqueueMapImage_ovr_5(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_5_anh0000010000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_5_anh0000001000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    private static function z_EnqueueMapImage_ovr_5_anh0000011000000(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: IntPtr; region: IntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clEnqueueMapImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; origin: array of UIntPtr; region: array of UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    if (origin<>nil) and (origin.Length<>0) then
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_5(command_queue, image, blocking_map, map_flags, origin[0], region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_5_anh0000001000000(command_queue, image, blocking_map, map_flags, origin[0], IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
      if (region<>nil) and (region.Length<>0) then
        z_EnqueueMapImage_ovr_5_anh0000010000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, region[0], image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret) else
        z_EnqueueMapImage_ovr_5_anh0000011000000(command_queue, image, blocking_map, map_flags, IntPtr.Zero, IntPtr.Zero, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMapImage_ovr_0(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
      z_EnqueueMapImage_ovr_0_anh0000000000100(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMapImage_ovr_1(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list[0], &event, errcode_ret) else
      z_EnqueueMapImage_ovr_1_anh0000000000100(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, IntPtr.Zero, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapImage_ovr_0(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapImage_ovr_1(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapImage_ovr_4(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMapImage(command_queue: cl_command_queue; image: cl_mem; blocking_map: Bool; map_flags: MapFlags; var origin: UIntPtr; var region: UIntPtr; var image_row_pitch: UIntPtr; var image_slice_pitch: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr; var errcode_ret: ErrorCode): IntPtr :=
    z_EnqueueMapImage_ovr_5(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, &event, errcode_ret);
    
    // added in cl1.0
    private static function z_EnqueueMarker_ovr_0(command_queue: cl_command_queue; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMarker';
    private static function z_EnqueueMarker_ovr_0_anh001(command_queue: cl_command_queue; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMarker';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarker(command_queue: cl_command_queue; &event: array of cl_event): ErrorCode :=
    if (&event<>nil) and (&event.Length<>0) then
      z_EnqueueMarker_ovr_0(command_queue, &event[0]) else
      z_EnqueueMarker_ovr_0_anh001(command_queue, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarker(command_queue: cl_command_queue; var &event: cl_event): ErrorCode :=
    z_EnqueueMarker_ovr_0(command_queue, &event);
    private static function z_EnqueueMarker_ovr_2(command_queue: cl_command_queue; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMarker';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarker(command_queue: cl_command_queue; &event: IntPtr): ErrorCode :=
    z_EnqueueMarker_ovr_2(command_queue, &event);
    
    // added in cl1.2
    private static function z_EnqueueMarkerWithWaitList_ovr_0(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMarkerWithWaitList';
    private static function z_EnqueueMarkerWithWaitList_ovr_0_anh00010(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMarkerWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarkerWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMarkerWithWaitList_ovr_0(command_queue, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMarkerWithWaitList_ovr_0_anh00010(command_queue, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarkerWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMarkerWithWaitList_ovr_0(command_queue, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMarkerWithWaitList_ovr_2(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMarkerWithWaitList';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMarkerWithWaitList(command_queue: cl_command_queue; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMarkerWithWaitList_ovr_2(command_queue, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.2
    private static function z_EnqueueMigrateMemObjects_ovr_0(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_0_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_0_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_0_anh00010010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjects_ovr_0(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjects_ovr_0_anh00000010(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjects_ovr_0_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjects_ovr_0_anh00010010(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_1(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_1_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_1_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_1_anh00010010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjects_ovr_1(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjects_ovr_1_anh00000010(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjects_ovr_1_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjects_ovr_1_anh00010010(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_2_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_0(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjects_ovr_0_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_3_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_1(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjects_ovr_1_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_4(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_4_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_4(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjects_ovr_4_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_5(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_5_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_5(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjects_ovr_5_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_0(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjects_ovr_0_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_1(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjects_ovr_1_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_0(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_1(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_4(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_5(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_12(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_12_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_12(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjects_ovr_12_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_13(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    private static function z_EnqueueMigrateMemObjects_ovr_13_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjects_ovr_13(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjects_ovr_13_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_12(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_13(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_16(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_16(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjects_ovr_17(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjects(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjects_ovr_17(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueNativeKernel_ovr_0(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_0(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_1(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_1(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_2(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_2(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_3(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_3(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_4(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_4(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_5(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_5(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_6(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_6(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_7(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; var mem_list: cl_mem; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_7(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_8(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_8(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_9(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_9(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_10(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_10(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_11(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; var args_mem_loc: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_11(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_12(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_12(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_13(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_13(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_14(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueNativeKernel_ovr_14(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNativeKernel_ovr_15(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNativeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNativeKernel(command_queue: cl_command_queue; user_func: EnqueueNativeKernelCallback; args: IntPtr; cb_args: UIntPtr; num_mem_objects: UInt32; mem_list: IntPtr; args_mem_loc: pointer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueNativeKernel_ovr_15(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueNDRangeKernel_ovr_0(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000100010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000010010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000110010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000001010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000101010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000011010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_0_anh0000111010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000000010(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000001010(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000010010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000011010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000100010(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000101010(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000110010(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_0_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_0_anh0000111010(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueNDRangeKernel_ovr_1(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000100010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000010010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000110010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000001010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000101010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000011010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_1_anh0000111010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000000010(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000001010(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000010010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000011010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000100010(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000101010(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000110010(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, IntPtr.Zero, &event) else
          if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
            z_EnqueueNDRangeKernel_ovr_1_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
            z_EnqueueNDRangeKernel_ovr_1_anh0000111010(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_2_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_0_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_0_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_0_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_0_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_0_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_0_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_0_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_3_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_1(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_1_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_1_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_1_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_1_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_1_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_1_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_1_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNDRangeKernel_ovr_4(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_4_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_4(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_4_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_4_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_4_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_4_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_4_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_4_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_4_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueNDRangeKernel_ovr_5(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000100000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000010000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000110000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000001000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000101000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000011000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    private static function z_EnqueueNDRangeKernel_ovr_5_anh0000111000(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueNDRangeKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; local_work_size: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_5(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_5_anh0000001000(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_5_anh0000010000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_5_anh0000011000(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_5_anh0000100000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_5_anh0000101000(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
        if (local_work_size<>nil) and (local_work_size.Length<>0) then
          z_EnqueueNDRangeKernel_ovr_5_anh0000110000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, local_work_size[0], num_events_in_wait_list, event_wait_list, &event) else
          z_EnqueueNDRangeKernel_ovr_5_anh0000111000(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueNDRangeKernel_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueNDRangeKernel_ovr_0_anh0000000010(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueNDRangeKernel_ovr_1(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueNDRangeKernel_ovr_1_anh0000000010(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueNDRangeKernel_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueNDRangeKernel_ovr_1(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueNDRangeKernel_ovr_4(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueNDRangeKernel(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueNDRangeKernel_ovr_5(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueReadBuffer_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private static function z_EnqueueReadBuffer_ovr_0_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_0<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueReadBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_0_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReadBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_0_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBuffer_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private static function z_EnqueueReadBuffer_ovr_1_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_1<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueReadBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_1_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReadBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_1_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_2<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_2_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_2(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_2_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_3<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_3_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_3(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_3_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBuffer_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_4<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_4(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_4_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBuffer_ovr_4(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_4(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_4_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBuffer_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_5<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_5(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueReadBuffer_ovr_5_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBuffer_ovr_5(command_queue, buffer, blocking_read, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueReadBuffer_ovr_5(command_queue, buffer, blocking_read, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueReadBuffer_ovr_5_anh0000001000(command_queue, buffer, blocking_read, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueReadBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueReadBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_0(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_1(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_4(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBuffer_ovr_5(command_queue, buffer, blocking_read, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBuffer_ovr_12(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private static function z_EnqueueReadBuffer_ovr_12_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReadBuffer_ovr_12(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReadBuffer_ovr_12_anh0000000010(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReadBuffer_ovr_13(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    private static function z_EnqueueReadBuffer_ovr_13_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReadBuffer_ovr_13(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReadBuffer_ovr_13_anh0000000010(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBuffer_ovr_12(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBuffer_ovr_13(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadBuffer_ovr_16(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBuffer_ovr_16(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadBuffer_ovr_17(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBuffer_ovr_17(command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.1
    private static function z_EnqueueReadBufferRect_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBufferRect_ovr_0(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBufferRect_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBufferRect_ovr_1(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBufferRect_ovr_2(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBufferRect_ovr_2(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBufferRect_ovr_3(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadBufferRect_ovr_3(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadBufferRect_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBufferRect_ovr_4(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadBufferRect_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBufferRect_ovr_5(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadBufferRect_ovr_6(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReadBufferRect_ovr_6(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadBufferRect_ovr_7(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_read: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReadBufferRect_ovr_7(command_queue, buffer, blocking_read, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueReadImage_ovr_0(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadImage_ovr_0(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadImage_ovr_1(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadImage_ovr_1(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadImage_ovr_2(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadImage_ovr_2(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadImage_ovr_3(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueReadImage_ovr_3(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueReadImage_ovr_4(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReadImage_ovr_4(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadImage_ovr_5(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReadImage_ovr_5(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadImage_ovr_6(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReadImage_ovr_6(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReadImage_ovr_7(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReadImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReadImage(command_queue: cl_command_queue; image: cl_mem; blocking_read: Bool; var origin: UIntPtr; var region: UIntPtr; row_pitch: UIntPtr; slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReadImage_ovr_7(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.0
    private static function z_EnqueueSVMFree_ovr_0(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_0_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_0_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_0_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFree_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFree_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFree_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFree_ovr_0_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFree_ovr_1(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_1_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_1_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_1_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFree_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFree_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFree_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFree_ovr_1_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFree_ovr_2_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFree_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFree_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_3_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFree_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFree_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_4(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_4_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFree_ovr_4(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFree_ovr_4_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_5(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_5_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFree_ovr_5(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFree_ovr_5_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFree_ovr_0(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFree_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFree_ovr_1(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFree_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFree_ovr_0(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFree_ovr_1(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFree_ovr_4(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFree_ovr_5(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_12(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_12_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFree_ovr_12(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFree_ovr_12_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFree_ovr_13(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    private static function z_EnqueueSVMFree_ovr_13_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFree_ovr_13(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFree_ovr_13_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFree_ovr_12(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFree_ovr_13(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_16(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFree_ovr_16(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFree_ovr_17(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFree(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFree_ovr_17(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.0
    private static function z_EnqueueSVMMap_ovr_0(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    private static function z_EnqueueSVMMap_ovr_0_anh000000010(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMap_ovr_0(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMap_ovr_0_anh000000010(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMap_ovr_1(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    private static function z_EnqueueSVMMap_ovr_1_anh000000010(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMap_ovr_1(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMap_ovr_1_anh000000010(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMap_ovr_0(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMap_ovr_1(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMap_ovr_4(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMap_ovr_4(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMap_ovr_5(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMap(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMap_ovr_5(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.0
    private static function z_EnqueueSVMMemcpy_ovr_0(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    private static function z_EnqueueSVMMemcpy_ovr_0_anh000000010(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemcpy_ovr_0(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemcpy_ovr_0_anh000000010(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMemcpy_ovr_1(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    private static function z_EnqueueSVMMemcpy_ovr_1_anh000000010(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemcpy_ovr_1(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemcpy_ovr_1_anh000000010(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemcpy_ovr_0(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemcpy_ovr_1(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemcpy_ovr_4(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemcpy_ovr_4(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemcpy_ovr_5(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpy';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpy(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemcpy_ovr_5(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.0
    private static function z_EnqueueSVMMemFill_ovr_0(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private static function z_EnqueueSVMMemFill_ovr_0_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_0<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueSVMMemFill_ovr_0_anh000000010(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_0_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFill_ovr_0_anh000000010(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_0_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueSVMMemFill_ovr_1(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private static function z_EnqueueSVMMemFill_ovr_1_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_1<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueSVMMemFill_ovr_1_anh000000010(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_1_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFill_ovr_1_anh000000010(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_1_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_2<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_2_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_2(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_2_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_3<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_3_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_3(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_3_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueSVMMemFill_ovr_4(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_4<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_4(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_4_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_4(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_4(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_4_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueSVMMemFill_ovr_5(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: Byte; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_5<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_5(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueSVMMemFill_ovr_5_anh000100000(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_5(command_queue, svm_ptr, PByte(nil)^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: array of T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (pattern<>nil) and (pattern.Length<>0) then
        Result := temp_EnqueueSVMMemFill_ovr_5(command_queue, svm_ptr, pattern[0], pattern_size, size, num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueSVMMemFill_ovr_5_anh000100000(command_queue, svm_ptr, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueSVMMemFill_ovr_0_anh000000010(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueSVMMemFill_ovr_1_anh000000010(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_0(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_1(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_4(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill<T>(command_queue: cl_command_queue; svm_ptr: IntPtr; var pattern: T; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueSVMMemFill_ovr_5(command_queue, svm_ptr, PByte(pointer(@pattern))^, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueSVMMemFill_ovr_12(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private static function z_EnqueueSVMMemFill_ovr_12_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFill_ovr_12(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFill_ovr_12_anh000000010(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMemFill_ovr_13(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    private static function z_EnqueueSVMMemFill_ovr_13_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFill_ovr_13(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFill_ovr_13_anh000000010(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_12(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_13(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemFill_ovr_16(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_16(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemFill_ovr_17(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFill';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFill(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFill_ovr_17(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.1
    private static function z_EnqueueSVMMigrateMem_ovr_0(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000010010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_0_anh000110010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_0_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_0_anh000010010(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_0_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_0_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_0_anh000110010(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_1(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000010010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_1_anh000110010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_1_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_1_anh000010010(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_1_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSVMMigrateMem_ovr_1_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSVMMigrateMem_ovr_1_anh000110010(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_2_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_2_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_2_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_0_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_0_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_3_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_3_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_3_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_1_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_1_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_4(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_4_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_4_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_4_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_4(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_4_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_4_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_4_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_5(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_5_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_5_anh000010000(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_5_anh000110000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; sizes: array of UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_5(command_queue, num_svm_pointers, svm_pointers[0], sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_5_anh000010000(command_queue, num_svm_pointers, svm_pointers[0], IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event) else
      if (sizes<>nil) and (sizes.Length<>0) then
        z_EnqueueSVMMigrateMem_ovr_5_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, sizes[0], flags, num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSVMMigrateMem_ovr_5_anh000110000(command_queue, num_svm_pointers, IntPtr.Zero, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMigrateMem_ovr_0(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMigrateMem_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMigrateMem_ovr_1(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMigrateMem_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_0(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_1(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_4(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; var sizes: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_5(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_12(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_12_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMigrateMem_ovr_12(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMigrateMem_ovr_12_anh000000010(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_13(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    private static function z_EnqueueSVMMigrateMem_ovr_13_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMigrateMem_ovr_13(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMigrateMem_ovr_13_anh000000010(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_12(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_13(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_16(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_16(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMigrateMem_ovr_17(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMigrateMem';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMigrateMem(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; sizes: IntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMigrateMem_ovr_17(command_queue, num_svm_pointers, svm_pointers, sizes, flags, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl2.0
    private static function z_EnqueueSVMUnmap_ovr_0(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    private static function z_EnqueueSVMUnmap_ovr_0_anh000010(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMUnmap_ovr_0(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMUnmap_ovr_0_anh000010(command_queue, svm_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMUnmap_ovr_1(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    private static function z_EnqueueSVMUnmap_ovr_1_anh000010(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMUnmap_ovr_1(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMUnmap_ovr_1_anh000010(command_queue, svm_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMUnmap_ovr_0(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMUnmap_ovr_1(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMUnmap_ovr_4(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMUnmap_ovr_4(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMUnmap_ovr_5(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmap';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmap(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMUnmap_ovr_5(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueTask_ovr_0(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    private static function z_EnqueueTask_ovr_0_anh000010(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueTask_ovr_0(command_queue, kernel, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueTask_ovr_0_anh000010(command_queue, kernel, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueTask_ovr_1(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    private static function z_EnqueueTask_ovr_1_anh000010(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueTask_ovr_1(command_queue, kernel, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueTask_ovr_1_anh000010(command_queue, kernel, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueTask_ovr_0(command_queue, kernel, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueTask_ovr_1(command_queue, kernel, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueTask_ovr_4(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueTask_ovr_4(command_queue, kernel, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueTask_ovr_5(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueTask';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueTask(command_queue: cl_command_queue; kernel: cl_kernel; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueTask_ovr_5(command_queue, kernel, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueUnmapMemObject_ovr_0(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    private static function z_EnqueueUnmapMemObject_ovr_0_anh0000010(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueUnmapMemObject_ovr_0(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueUnmapMemObject_ovr_0_anh0000010(command_queue, memobj, mapped_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueUnmapMemObject_ovr_1(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    private static function z_EnqueueUnmapMemObject_ovr_1_anh0000010(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueUnmapMemObject_ovr_1(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueUnmapMemObject_ovr_1_anh0000010(command_queue, memobj, mapped_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueUnmapMemObject_ovr_0(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueUnmapMemObject_ovr_1(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueUnmapMemObject_ovr_4(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueUnmapMemObject_ovr_4(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueUnmapMemObject_ovr_5(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueUnmapMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueUnmapMemObject(command_queue: cl_command_queue; memobj: cl_mem; mapped_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueUnmapMemObject_ovr_5(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueWaitForEvents_ovr_0(command_queue: cl_command_queue; num_events: UInt32; var event_list: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitForEvents';
    private static function z_EnqueueWaitForEvents_ovr_0_anh0001(command_queue: cl_command_queue; num_events: UInt32; event_list: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitForEvents';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitForEvents(command_queue: cl_command_queue; num_events: UInt32; event_list: array of cl_event): ErrorCode :=
    if (event_list<>nil) and (event_list.Length<>0) then
      z_EnqueueWaitForEvents_ovr_0(command_queue, num_events, event_list[0]) else
      z_EnqueueWaitForEvents_ovr_0_anh0001(command_queue, num_events, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitForEvents(command_queue: cl_command_queue; num_events: UInt32; var event_list: cl_event): ErrorCode :=
    z_EnqueueWaitForEvents_ovr_0(command_queue, num_events, event_list);
    private static function z_EnqueueWaitForEvents_ovr_2(command_queue: cl_command_queue; num_events: UInt32; event_list: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitForEvents';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitForEvents(command_queue: cl_command_queue; num_events: UInt32; event_list: IntPtr): ErrorCode :=
    z_EnqueueWaitForEvents_ovr_2(command_queue, num_events, event_list);
    
    // added in cl1.0
    private static function z_EnqueueWriteBuffer_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private static function z_EnqueueWriteBuffer_ovr_0_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_0<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueWriteBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_0_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWriteBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_0_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBuffer_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private static function z_EnqueueWriteBuffer_ovr_1_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_1<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueWriteBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_1_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWriteBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_1_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_2<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_2_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_2(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_2_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_3<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_3_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_3(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_3_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBuffer_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_4<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_4(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_4_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_4(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_4(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_4_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBuffer_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_5<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_5(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_EnqueueWriteBuffer_ovr_5_anh0000001000(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_5(command_queue, buffer, blocking_write, offset, size, PByte(nil)^, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: array of T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (ptr<>nil) and (ptr.Length<>0) then
        Result := temp_EnqueueWriteBuffer_ovr_5(command_queue, buffer, blocking_write, offset, size, ptr[0], num_events_in_wait_list, event_wait_list, &event) else
        Result := temp_EnqueueWriteBuffer_ovr_5_anh0000001000(command_queue, buffer, blocking_write, offset, size, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueWriteBuffer_ovr_0_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        Result := z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list[0], &event) else
        Result := z_EnqueueWriteBuffer_ovr_1_anh0000000010(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, IntPtr.Zero, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_0(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_1(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_4(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBuffer_ovr_5(command_queue, buffer, blocking_write, offset, size, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBuffer_ovr_12(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private static function z_EnqueueWriteBuffer_ovr_12_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWriteBuffer_ovr_12(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWriteBuffer_ovr_12_anh0000000010(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWriteBuffer_ovr_13(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    private static function z_EnqueueWriteBuffer_ovr_13_anh0000000010(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWriteBuffer_ovr_13(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWriteBuffer_ovr_13_anh0000000010(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_12(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_13(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteBuffer_ovr_16(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_16(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteBuffer_ovr_17(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBuffer(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; offset: UIntPtr; size: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBuffer_ovr_17(command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.1
    private static function z_EnqueueWriteBufferRect_ovr_0(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBufferRect_ovr_0(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBufferRect_ovr_1(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBufferRect_ovr_1(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBufferRect_ovr_2(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBufferRect_ovr_2(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBufferRect_ovr_3(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect<T>(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteBufferRect_ovr_3(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteBufferRect_ovr_4(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBufferRect_ovr_4(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteBufferRect_ovr_5(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBufferRect_ovr_5(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteBufferRect_ovr_6(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteBufferRect_ovr_6(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteBufferRect_ovr_7(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteBufferRect';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteBufferRect(command_queue: cl_command_queue; buffer: cl_mem; blocking_write: Bool; var buffer_origin: UIntPtr; var host_origin: UIntPtr; var region: UIntPtr; buffer_row_pitch: UIntPtr; buffer_slice_pitch: UIntPtr; host_row_pitch: UIntPtr; host_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteBufferRect_ovr_7(command_queue, buffer, blocking_write, buffer_origin, host_origin, region, buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_EnqueueWriteImage_ovr_0(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteImage_ovr_0(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteImage_ovr_1(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteImage_ovr_1(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteImage_ovr_2(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteImage_ovr_2(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteImage_ovr_3(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: Byte; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage<T>(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; var ptr: T; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_EnqueueWriteImage_ovr_3(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, PByte(pointer(@ptr))^, num_events_in_wait_list, event_wait_list, &event);
    end;
    private static function z_EnqueueWriteImage_ovr_4(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteImage_ovr_4(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteImage_ovr_5(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteImage_ovr_5(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteImage_ovr_6(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWriteImage_ovr_6(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWriteImage_ovr_7(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWriteImage';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWriteImage(command_queue: cl_command_queue; image: cl_mem; blocking_write: Bool; var origin: UIntPtr; var region: UIntPtr; input_row_pitch: UIntPtr; input_slice_pitch: UIntPtr; ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWriteImage_ovr_7(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, &event);
    
    // added in cl1.0
    private static function z_Finish_ovr_0(command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clFinish';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function Finish(command_queue: cl_command_queue): ErrorCode :=
    z_Finish_ovr_0(command_queue);
    
    // added in cl1.0
    private static function z_Flush_ovr_0(command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clFlush';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function Flush(command_queue: cl_command_queue): ErrorCode :=
    z_Flush_ovr_0(command_queue);
    
    // added in cl1.0
    private static function z_GetCommandQueueInfo_ovr_0(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_0(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_1(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_1(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_2(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_2(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_3(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_3(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_4(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_4(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_5(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_5(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_6(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_6(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_7(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_7(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_8(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_8(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_9(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_9(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_10(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_10(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandQueueInfo_ovr_11(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandQueueInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandQueueInfo(command_queue: cl_command_queue; param_name: CommandQueueInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandQueueInfo_ovr_11(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetContextInfo_ovr_0(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetContextInfo_ovr_0(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_1(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetContextInfo_ovr_1(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_2(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetContextInfo_ovr_2(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_3(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetContextInfo_ovr_3(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_4(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: ContextProperties; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: ContextProperties; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetContextInfo_ovr_4(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_5(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: ContextProperties; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; var param_value: ContextProperties; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetContextInfo_ovr_5(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_6(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetContextInfo_ovr_6(context, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetContextInfo_ovr_7(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetContextInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextInfo(context: cl_context; param_name: ContextInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetContextInfo_ovr_7(context, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl2.1
    private static function z_GetDeviceAndHostTimer_ovr_0(device: cl_device_id; var device_timestamp: UInt64; var host_timestamp: UInt64): ErrorCode;
    external 'opencl' name 'clGetDeviceAndHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceAndHostTimer(device: cl_device_id; var device_timestamp: UInt64; var host_timestamp: UInt64): ErrorCode :=
    z_GetDeviceAndHostTimer_ovr_0(device, device_timestamp, host_timestamp);
    private static function z_GetDeviceAndHostTimer_ovr_1(device: cl_device_id; var device_timestamp: UInt64; host_timestamp: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceAndHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceAndHostTimer(device: cl_device_id; var device_timestamp: UInt64; host_timestamp: IntPtr): ErrorCode :=
    z_GetDeviceAndHostTimer_ovr_1(device, device_timestamp, host_timestamp);
    private static function z_GetDeviceAndHostTimer_ovr_2(device: cl_device_id; device_timestamp: IntPtr; var host_timestamp: UInt64): ErrorCode;
    external 'opencl' name 'clGetDeviceAndHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceAndHostTimer(device: cl_device_id; device_timestamp: IntPtr; var host_timestamp: UInt64): ErrorCode :=
    z_GetDeviceAndHostTimer_ovr_2(device, device_timestamp, host_timestamp);
    private static function z_GetDeviceAndHostTimer_ovr_3(device: cl_device_id; device_timestamp: IntPtr; host_timestamp: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceAndHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceAndHostTimer(device: cl_device_id; device_timestamp: IntPtr; host_timestamp: IntPtr): ErrorCode :=
    z_GetDeviceAndHostTimer_ovr_3(device, device_timestamp, host_timestamp);
    
    // added in cl1.0
    private static function z_GetDeviceIDs_ovr_0(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDs(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDs_ovr_0(platform, device_type, num_entries, devices, num_devices);
    private static function z_GetDeviceIDs_ovr_1(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDs(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDs_ovr_1(platform, device_type, num_entries, devices, num_devices);
    private static function z_GetDeviceIDs_ovr_2(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDs(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDs_ovr_2(platform, device_type, num_entries, devices, num_devices);
    private static function z_GetDeviceIDs_ovr_3(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDs(platform: cl_platform_id; device_type: DeviceType; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDs_ovr_3(platform, device_type, num_entries, devices, num_devices);
    
    // added in cl1.0
    private static function z_GetDeviceInfo_ovr_0(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_0(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_1(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_1(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_2(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_2(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_3(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_3(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_4(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_4(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_5(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_5(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_6(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_6(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_7(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_7(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_8(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_8(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_9(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_9(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_10(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_10(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_11(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_11(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_12(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceFPConfig; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceFPConfig; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_12(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_13(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceFPConfig; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceFPConfig; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_13(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_14(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceMemCacheType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceMemCacheType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_14(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_15(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceMemCacheType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceMemCacheType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_15(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_16(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceLocalMemType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceLocalMemType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_16(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_17(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceLocalMemType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceLocalMemType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_17(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_18(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceExecCapabilities; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceExecCapabilities; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_18(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_19(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceExecCapabilities; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceExecCapabilities; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_19(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_20(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_20(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_21(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: CommandQueueProperties; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_21(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_22(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_platform_id; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_platform_id; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_22(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_23(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_platform_id; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_platform_id; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_23(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_24(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_24(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_25(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_25(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_26(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DevicePartitionProperty; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DevicePartitionProperty; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_26(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_27(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DevicePartitionProperty; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DevicePartitionProperty; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_27(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_28(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceAffinityDomain; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceAffinityDomain; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_28(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_29(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceAffinityDomain; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceAffinityDomain; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_29(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_30(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceSVMCapabilities; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceSVMCapabilities; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_30(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_31(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceSVMCapabilities; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; var param_value: DeviceSVMCapabilities; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_31(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_32(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_32(device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceInfo_ovr_33(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceInfo(device: cl_device_id; param_name: DeviceInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceInfo_ovr_33(device, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetEventInfo_ovr_0(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_0(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_1(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_command_queue; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_1(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_2(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_2(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_3(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_3(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_4(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_4(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_5(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_5(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_6(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandExecutionStatus; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandExecutionStatus; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_6(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_7(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandExecutionStatus; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: CommandExecutionStatus; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_7(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_8(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_8(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_9(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_9(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_10(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventInfo_ovr_10(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventInfo_ovr_11(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventInfo(&event: cl_event; param_name: EventInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventInfo_ovr_11(&event, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetEventProfilingInfo_ovr_0(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventProfilingInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventProfilingInfo(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventProfilingInfo_ovr_0(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventProfilingInfo_ovr_1(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventProfilingInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventProfilingInfo(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventProfilingInfo_ovr_1(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventProfilingInfo_ovr_2(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetEventProfilingInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventProfilingInfo(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetEventProfilingInfo_ovr_2(&event, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetEventProfilingInfo_ovr_3(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetEventProfilingInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEventProfilingInfo(&event: cl_event; param_name: ProfilingInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetEventProfilingInfo_ovr_3(&event, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetExtensionFunctionAddress_ovr_0(func_name: IntPtr): IntPtr;
    external 'opencl' name 'clGetExtensionFunctionAddress';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionFunctionAddress(func_name: string): IntPtr;
    begin
      var par_1_str_ptr: IntPtr;
      try
        par_1_str_ptr := Marshal.StringToHGlobalAnsi(func_name);
        Result := z_GetExtensionFunctionAddress_ovr_0(par_1_str_ptr);
      finally
        Marshal.FreeHGlobal(par_1_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionFunctionAddress(func_name: IntPtr): IntPtr :=
    z_GetExtensionFunctionAddress_ovr_0(func_name);
    
    // added in cl1.2
    private static function z_GetExtensionFunctionAddressForPlatform_ovr_0(platform: cl_platform_id; func_name: IntPtr): IntPtr;
    external 'opencl' name 'clGetExtensionFunctionAddressForPlatform';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionFunctionAddressForPlatform(platform: cl_platform_id; func_name: string): IntPtr;
    begin
      var par_2_str_ptr: IntPtr;
      try
        par_2_str_ptr := Marshal.StringToHGlobalAnsi(func_name);
        Result := z_GetExtensionFunctionAddressForPlatform_ovr_0(platform, par_2_str_ptr);
      finally
        Marshal.FreeHGlobal(par_2_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionFunctionAddressForPlatform(platform: cl_platform_id; func_name: IntPtr): IntPtr :=
    z_GetExtensionFunctionAddressForPlatform_ovr_0(platform, func_name);
    
    // added in cl2.1
    private static function z_GetHostTimer_ovr_0(device: cl_device_id; var host_timestamp: UInt64): ErrorCode;
    external 'opencl' name 'clGetHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetHostTimer(device: cl_device_id; var host_timestamp: UInt64): ErrorCode :=
    z_GetHostTimer_ovr_0(device, host_timestamp);
    private static function z_GetHostTimer_ovr_1(device: cl_device_id; host_timestamp: IntPtr): ErrorCode;
    external 'opencl' name 'clGetHostTimer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetHostTimer(device: cl_device_id; host_timestamp: IntPtr): ErrorCode :=
    z_GetHostTimer_ovr_1(device, host_timestamp);
    
    // added in cl1.0
    private static function z_GetImageInfo_ovr_0(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: cl_image_format; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: cl_image_format; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetImageInfo_ovr_0(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_1(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: cl_image_format; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: cl_image_format; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetImageInfo_ovr_1(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_2(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetImageInfo_ovr_2(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_3(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetImageInfo_ovr_3(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_4(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetImageInfo_ovr_4(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_5(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetImageInfo_ovr_5(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_6(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetImageInfo_ovr_6(image, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetImageInfo_ovr_7(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetImageInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetImageInfo(image: cl_mem; param_name: ImageInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetImageInfo_ovr_7(image, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.2
    private static function z_GetKernelArgInfo_ovr_0(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAddressQualifier; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAddressQualifier; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_0(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_1(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAddressQualifier; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAddressQualifier; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_1(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_2(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAccessQualifier; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAccessQualifier; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_2(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_3(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAccessQualifier; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgAccessQualifier; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_3(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_4(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_4(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_5(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_5(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_6(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgTypeQualifier; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgTypeQualifier; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_6(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_7(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgTypeQualifier; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; var param_value: KernelArgTypeQualifier; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_7(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_8(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_8(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelArgInfo_ovr_9(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelArgInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelArgInfo(kernel: cl_kernel; arg_index: UInt32; param_name: KernelArgInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelArgInfo_ovr_9(kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetKernelInfo_ovr_0(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_0(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_1(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_1(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_2(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_2(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_3(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_3(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_4(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_4(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_5(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_5(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_6(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_program; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_program; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_6(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_7(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_program; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; var param_value: cl_program; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_7(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_8(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_8(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelInfo_ovr_9(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelInfo(kernel: cl_kernel; param_name: KernelInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelInfo_ovr_9(kernel, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl2.1
    private static function z_GetKernelSubGroupInfo_ovr_0(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; var input_value: UIntPtr; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; var input_value: UIntPtr; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_0(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfo_ovr_1(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; var input_value: UIntPtr; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; var input_value: UIntPtr; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_1(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfo_ovr_2(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_2(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfo_ovr_3(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_3(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfo_ovr_4(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_4(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfo_ovr_5(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: pointer; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelSubGroupInfo_ovr_5(kernel, device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetKernelWorkGroupInfo_ovr_0(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_0(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelWorkGroupInfo_ovr_1(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_1(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelWorkGroupInfo_ovr_2(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_2(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelWorkGroupInfo_ovr_3(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_3(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelWorkGroupInfo_ovr_4(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_4(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelWorkGroupInfo_ovr_5(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelWorkGroupInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelWorkGroupInfo(kernel: cl_kernel; device: cl_device_id; param_name: KernelWorkGroupInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelWorkGroupInfo_ovr_5(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetMemObjectInfo_ovr_0(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemObjectType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemObjectType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_0(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_1(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemObjectType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemObjectType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_1(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_2(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemFlags; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemFlags; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_2(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_3(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemFlags; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: MemFlags; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_3(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_4(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_4(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_5(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_5(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_6(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_6(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_7(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_7(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_8(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_8(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_9(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_9(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_10(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_10(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_11(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_11(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_12(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_mem; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_mem; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_12(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_13(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_mem; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: cl_mem; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_13(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_14(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_14(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_15(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_15(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_16(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_16(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemObjectInfo_ovr_17(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemObjectInfo(memobj: cl_mem; param_name: MemInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemObjectInfo_ovr_17(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl2.0
    private static function z_GetPipeInfo_ovr_0(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetPipeInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPipeInfo(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetPipeInfo_ovr_0(pipe, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPipeInfo_ovr_1(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPipeInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPipeInfo(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetPipeInfo_ovr_1(pipe, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPipeInfo_ovr_2(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetPipeInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPipeInfo(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetPipeInfo_ovr_2(pipe, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPipeInfo_ovr_3(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPipeInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPipeInfo(pipe: cl_mem; param_name: PipeInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetPipeInfo_ovr_3(pipe, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetPlatformIDs_ovr_0(num_entries: UInt32; var platforms: cl_platform_id; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clGetPlatformIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformIDs(num_entries: UInt32; var platforms: cl_platform_id; var num_platforms: UInt32): ErrorCode :=
    z_GetPlatformIDs_ovr_0(num_entries, platforms, num_platforms);
    private static function z_GetPlatformIDs_ovr_1(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformIDs(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: IntPtr): ErrorCode :=
    z_GetPlatformIDs_ovr_1(num_entries, platforms, num_platforms);
    private static function z_GetPlatformIDs_ovr_2(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clGetPlatformIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformIDs(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode :=
    z_GetPlatformIDs_ovr_2(num_entries, platforms, num_platforms);
    private static function z_GetPlatformIDs_ovr_3(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformIDs';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformIDs(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode :=
    z_GetPlatformIDs_ovr_3(num_entries, platforms, num_platforms);
    
    // added in cl1.0
    private static function z_GetPlatformInfo_ovr_0(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_0(platform, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPlatformInfo_ovr_1(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_1(platform, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPlatformInfo_ovr_2(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; var param_value: UInt64; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_2(platform, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPlatformInfo_ovr_3(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; var param_value: UInt64; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_3(platform, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPlatformInfo_ovr_4(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_4(platform, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetPlatformInfo_ovr_5(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetPlatformInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPlatformInfo(platform: cl_platform_id; param_name: PlatformInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetPlatformInfo_ovr_5(platform, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetProgramBuildInfo_ovr_0(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: BuildStatus; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: BuildStatus; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_0(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_1(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: BuildStatus; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: BuildStatus; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_1(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_2(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_2(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_3(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_3(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_4(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: ProgramBinaryType; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: ProgramBinaryType; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_4(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_5(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: ProgramBinaryType; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: ProgramBinaryType; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_5(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_6(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_6(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_7(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_7(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_8(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_8(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramBuildInfo_ovr_9(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramBuildInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramBuildInfo(&program: cl_program; device: cl_device_id; param_name: ProgramBuildInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramBuildInfo_ovr_9(&program, device, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetProgramInfo_ovr_0(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_0(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_1(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_1(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_2(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_2(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_3(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_3(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_4(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_device_id; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_4(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_5(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: cl_device_id; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_5(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_6(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_6(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_7(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_7(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_8(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UIntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_8(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_9(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: UIntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_9(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_10(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Byte; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Byte; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_10(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_11(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Byte; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Byte; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_11(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_12(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_12(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_13(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_13(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_14(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_14(&program, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetProgramInfo_ovr_15(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetProgramInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProgramInfo(&program: cl_program; param_name: ProgramInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetProgramInfo_ovr_15(&program, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetSamplerInfo_ovr_0(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: UInt32; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_0(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_1(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: UInt32; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_1(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_2(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: cl_context; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_2(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_3(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: cl_context; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_3(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_4(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: Bool; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_4(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_5(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: Bool; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_5(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_6(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: AddressingMode; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: AddressingMode; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_6(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_7(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: AddressingMode; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: AddressingMode; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_7(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_8(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: FilterMode; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: FilterMode; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_8(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_9(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: FilterMode; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; var param_value: FilterMode; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_9(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_10(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; param_value: pointer; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_10(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSamplerInfo_ovr_11(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSamplerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSamplerInfo(sampler: cl_sampler; param_name: SamplerInfo; param_value_size: UIntPtr; param_value: pointer; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSamplerInfo_ovr_11(sampler, param_name, param_value_size, param_value, param_value_size_ret);
    
    // added in cl1.0
    private static function z_GetSupportedImageFormats_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; var num_image_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    private static function z_GetSupportedImageFormats_ovr_0_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; var num_image_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    private static function z_GetSupportedImageFormats_ovr_0_anh0000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    private static function z_GetSupportedImageFormats_ovr_0_anh0000011(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: array of cl_image_format; num_image_formats: array of UInt32): ErrorCode :=
    if (image_formats<>nil) and (image_formats.Length<>0) then
      if (num_image_formats<>nil) and (num_image_formats.Length<>0) then
        z_GetSupportedImageFormats_ovr_0(context, flags, image_type, num_entries, image_formats[0], num_image_formats[0]) else
        z_GetSupportedImageFormats_ovr_0_anh0000001(context, flags, image_type, num_entries, image_formats[0], IntPtr.Zero) else
      if (num_image_formats<>nil) and (num_image_formats.Length<>0) then
        z_GetSupportedImageFormats_ovr_0_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_image_formats[0]) else
        z_GetSupportedImageFormats_ovr_0_anh0000011(context, flags, image_type, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetSupportedImageFormats_ovr_1_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; var num_image_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: array of cl_image_format; var num_image_formats: UInt32): ErrorCode :=
    if (image_formats<>nil) and (image_formats.Length<>0) then
      z_GetSupportedImageFormats_ovr_0(context, flags, image_type, num_entries, image_formats[0], num_image_formats) else
      z_GetSupportedImageFormats_ovr_0_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_image_formats);
    private static function z_GetSupportedImageFormats_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    private static function z_GetSupportedImageFormats_ovr_2_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: array of cl_image_format; num_image_formats: IntPtr): ErrorCode :=
    if (image_formats<>nil) and (image_formats.Length<>0) then
      z_GetSupportedImageFormats_ovr_2(context, flags, image_type, num_entries, image_formats[0], num_image_formats) else
      z_GetSupportedImageFormats_ovr_2_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_image_formats);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; num_image_formats: array of UInt32): ErrorCode :=
    if (num_image_formats<>nil) and (num_image_formats.Length<>0) then
      z_GetSupportedImageFormats_ovr_0(context, flags, image_type, num_entries, image_formats, num_image_formats[0]) else
      z_GetSupportedImageFormats_ovr_0_anh0000001(context, flags, image_type, num_entries, image_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; var num_image_formats: UInt32): ErrorCode :=
    z_GetSupportedImageFormats_ovr_0(context, flags, image_type, num_entries, image_formats, num_image_formats);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var image_formats: cl_image_format; num_image_formats: IntPtr): ErrorCode :=
    z_GetSupportedImageFormats_ovr_2(context, flags, image_type, num_entries, image_formats, num_image_formats);
    private static function z_GetSupportedImageFormats_ovr_6(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; var num_image_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    private static function z_GetSupportedImageFormats_ovr_6_anh0000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: array of UInt32): ErrorCode :=
    if (num_image_formats<>nil) and (num_image_formats.Length<>0) then
      z_GetSupportedImageFormats_ovr_6(context, flags, image_type, num_entries, image_formats, num_image_formats[0]) else
      z_GetSupportedImageFormats_ovr_6_anh0000001(context, flags, image_type, num_entries, image_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; var num_image_formats: UInt32): ErrorCode :=
    z_GetSupportedImageFormats_ovr_6(context, flags, image_type, num_entries, image_formats, num_image_formats);
    private static function z_GetSupportedImageFormats_ovr_8(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedImageFormats';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedImageFormats(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; image_formats: IntPtr; num_image_formats: IntPtr): ErrorCode :=
    z_GetSupportedImageFormats_ovr_8(context, flags, image_type, num_entries, image_formats, num_image_formats);
    
    // added in cl1.2
    private static function z_LinkProgram_ovr_0(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_0_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_0_anh0000001000(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_0_anh0001001000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: string; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (device_list<>nil) and (device_list.Length<>0) then
          if (input_programs<>nil) and (input_programs.Length<>0) then
            Result := z_LinkProgram_ovr_0(context, num_devices, device_list[0], par_4_str_ptr, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
            Result := z_LinkProgram_ovr_0_anh0000001000(context, num_devices, device_list[0], par_4_str_ptr, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret) else
          if (input_programs<>nil) and (input_programs.Length<>0) then
            Result := z_LinkProgram_ovr_0_anh0001000000(context, num_devices, IntPtr.Zero, par_4_str_ptr, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
            Result := z_LinkProgram_ovr_0_anh0001001000(context, num_devices, IntPtr.Zero, par_4_str_ptr, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_LinkProgram_ovr_1_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: string; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (device_list<>nil) and (device_list.Length<>0) then
          Result := z_LinkProgram_ovr_0(context, num_devices, device_list[0], par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret) else
          Result := z_LinkProgram_ovr_0_anh0001000000(context, num_devices, IntPtr.Zero, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_LinkProgram_ovr_2(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_2_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: string; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (device_list<>nil) and (device_list.Length<>0) then
          Result := z_LinkProgram_ovr_2(context, num_devices, device_list[0], par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret) else
          Result := z_LinkProgram_ovr_2_anh0001000000(context, num_devices, IntPtr.Zero, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_LinkProgram_ovr_3_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_3_anh0001001000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (device_list<>nil) and (device_list.Length<>0) then
      if (input_programs<>nil) and (input_programs.Length<>0) then
        z_LinkProgram_ovr_0(context, num_devices, device_list[0], options, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
        z_LinkProgram_ovr_0_anh0000001000(context, num_devices, device_list[0], options, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret) else
      if (input_programs<>nil) and (input_programs.Length<>0) then
        z_LinkProgram_ovr_0_anh0001000000(context, num_devices, IntPtr.Zero, options, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
        z_LinkProgram_ovr_0_anh0001001000(context, num_devices, IntPtr.Zero, options, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    private static function z_LinkProgram_ovr_4_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (device_list<>nil) and (device_list.Length<>0) then
      z_LinkProgram_ovr_0(context, num_devices, device_list[0], options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret) else
      z_LinkProgram_ovr_0_anh0001000000(context, num_devices, IntPtr.Zero, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    private static function z_LinkProgram_ovr_5_anh0001000000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: array of cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (device_list<>nil) and (device_list.Length<>0) then
      z_LinkProgram_ovr_2(context, num_devices, device_list[0], options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret) else
      z_LinkProgram_ovr_2_anh0001000000(context, num_devices, IntPtr.Zero, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (input_programs<>nil) and (input_programs.Length<>0) then
          Result := z_LinkProgram_ovr_0(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
          Result := z_LinkProgram_ovr_0_anh0000001000(context, num_devices, device_list, par_4_str_ptr, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_LinkProgram_ovr_0(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: string; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_LinkProgram_ovr_2(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (input_programs<>nil) and (input_programs.Length<>0) then
      z_LinkProgram_ovr_0(context, num_devices, device_list, options, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
      z_LinkProgram_ovr_0_anh0000001000(context, num_devices, device_list, options, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_LinkProgram_ovr_0(context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; var device_list: cl_device_id; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_LinkProgram_ovr_2(context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    private static function z_LinkProgram_ovr_12(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    private static function z_LinkProgram_ovr_12_anh0000001000(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: string; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        if (input_programs<>nil) and (input_programs.Length<>0) then
          Result := z_LinkProgram_ovr_12(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
          Result := z_LinkProgram_ovr_12_anh0000001000(context, num_devices, device_list, par_4_str_ptr, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: string; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_LinkProgram_ovr_12(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    private static function z_LinkProgram_ovr_14(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clLinkProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: string; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program;
    begin
      var par_4_str_ptr: IntPtr;
      try
        par_4_str_ptr := Marshal.StringToHGlobalAnsi(options);
        Result := z_LinkProgram_ovr_14(context, num_devices, device_list, par_4_str_ptr, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
      finally
        Marshal.FreeHGlobal(par_4_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: array of cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (input_programs<>nil) and (input_programs.Length<>0) then
      z_LinkProgram_ovr_12(context, num_devices, device_list, options, num_input_programs, input_programs[0], pfn_notify, user_data, errcode_ret) else
      z_LinkProgram_ovr_12_anh0000001000(context, num_devices, device_list, options, num_input_programs, IntPtr.Zero, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; var input_programs: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_LinkProgram_ovr_12(context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LinkProgram(context: cl_context; num_devices: UInt32; device_list: IntPtr; options: IntPtr; num_input_programs: UInt32; input_programs: IntPtr; pfn_notify: ProgramCallback; user_data: IntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_LinkProgram_ovr_14(context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret);
    
    // added in cl1.0
    private static function z_ReleaseCommandQueue_ovr_0(command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clReleaseCommandQueue';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseCommandQueue(command_queue: cl_command_queue): ErrorCode :=
    z_ReleaseCommandQueue_ovr_0(command_queue);
    
    // added in cl1.0
    private static function z_ReleaseContext_ovr_0(context: cl_context): ErrorCode;
    external 'opencl' name 'clReleaseContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseContext(context: cl_context): ErrorCode :=
    z_ReleaseContext_ovr_0(context);
    
    // added in cl1.2
    private static function z_ReleaseDevice_ovr_0(device: cl_device_id): ErrorCode;
    external 'opencl' name 'clReleaseDevice';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseDevice(device: cl_device_id): ErrorCode :=
    z_ReleaseDevice_ovr_0(device);
    
    // added in cl1.0
    private static function z_ReleaseEvent_ovr_0(&event: cl_event): ErrorCode;
    external 'opencl' name 'clReleaseEvent';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseEvent(&event: cl_event): ErrorCode :=
    z_ReleaseEvent_ovr_0(&event);
    
    // added in cl1.0
    private static function z_ReleaseKernel_ovr_0(kernel: cl_kernel): ErrorCode;
    external 'opencl' name 'clReleaseKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseKernel(kernel: cl_kernel): ErrorCode :=
    z_ReleaseKernel_ovr_0(kernel);
    
    // added in cl1.0
    private static function z_ReleaseMemObject_ovr_0(memobj: cl_mem): ErrorCode;
    external 'opencl' name 'clReleaseMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseMemObject(memobj: cl_mem): ErrorCode :=
    z_ReleaseMemObject_ovr_0(memobj);
    
    // added in cl1.0
    private static function z_ReleaseProgram_ovr_0(&program: cl_program): ErrorCode;
    external 'opencl' name 'clReleaseProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseProgram(&program: cl_program): ErrorCode :=
    z_ReleaseProgram_ovr_0(&program);
    
    // added in cl1.0
    private static function z_ReleaseSampler_ovr_0(sampler: cl_sampler): ErrorCode;
    external 'opencl' name 'clReleaseSampler';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseSampler(sampler: cl_sampler): ErrorCode :=
    z_ReleaseSampler_ovr_0(sampler);
    
    // added in cl1.0
    private static function z_RetainCommandQueue_ovr_0(command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clRetainCommandQueue';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainCommandQueue(command_queue: cl_command_queue): ErrorCode :=
    z_RetainCommandQueue_ovr_0(command_queue);
    
    // added in cl1.0
    private static function z_RetainContext_ovr_0(context: cl_context): ErrorCode;
    external 'opencl' name 'clRetainContext';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainContext(context: cl_context): ErrorCode :=
    z_RetainContext_ovr_0(context);
    
    // added in cl1.2
    private static function z_RetainDevice_ovr_0(device: cl_device_id): ErrorCode;
    external 'opencl' name 'clRetainDevice';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainDevice(device: cl_device_id): ErrorCode :=
    z_RetainDevice_ovr_0(device);
    
    // added in cl1.0
    private static function z_RetainEvent_ovr_0(&event: cl_event): ErrorCode;
    external 'opencl' name 'clRetainEvent';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainEvent(&event: cl_event): ErrorCode :=
    z_RetainEvent_ovr_0(&event);
    
    // added in cl1.0
    private static function z_RetainKernel_ovr_0(kernel: cl_kernel): ErrorCode;
    external 'opencl' name 'clRetainKernel';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainKernel(kernel: cl_kernel): ErrorCode :=
    z_RetainKernel_ovr_0(kernel);
    
    // added in cl1.0
    private static function z_RetainMemObject_ovr_0(memobj: cl_mem): ErrorCode;
    external 'opencl' name 'clRetainMemObject';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainMemObject(memobj: cl_mem): ErrorCode :=
    z_RetainMemObject_ovr_0(memobj);
    
    // added in cl1.0
    private static function z_RetainProgram_ovr_0(&program: cl_program): ErrorCode;
    external 'opencl' name 'clRetainProgram';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainProgram(&program: cl_program): ErrorCode :=
    z_RetainProgram_ovr_0(&program);
    
    // added in cl1.0
    private static function z_RetainSampler_ovr_0(sampler: cl_sampler): ErrorCode;
    external 'opencl' name 'clRetainSampler';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainSampler(sampler: cl_sampler): ErrorCode :=
    z_RetainSampler_ovr_0(sampler);
    
    // added in cl1.0
    private static function z_SetCommandQueueProperty_ovr_0(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; var old_properties: CommandQueueProperties): ErrorCode;
    external 'opencl' name 'clSetCommandQueueProperty';
    private static function z_SetCommandQueueProperty_ovr_0_anh00001(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; old_properties: IntPtr): ErrorCode;
    external 'opencl' name 'clSetCommandQueueProperty';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetCommandQueueProperty(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; old_properties: array of CommandQueueProperties): ErrorCode :=
    if (old_properties<>nil) and (old_properties.Length<>0) then
      z_SetCommandQueueProperty_ovr_0(command_queue, properties, enable, old_properties[0]) else
      z_SetCommandQueueProperty_ovr_0_anh00001(command_queue, properties, enable, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetCommandQueueProperty(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; var old_properties: CommandQueueProperties): ErrorCode :=
    z_SetCommandQueueProperty_ovr_0(command_queue, properties, enable, old_properties);
    private static function z_SetCommandQueueProperty_ovr_2(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; old_properties: IntPtr): ErrorCode;
    external 'opencl' name 'clSetCommandQueueProperty';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetCommandQueueProperty(command_queue: cl_command_queue; properties: CommandQueueProperties; enable: Bool; old_properties: IntPtr): ErrorCode :=
    z_SetCommandQueueProperty_ovr_2(command_queue, properties, enable, old_properties);
    
    // added in cl3.0
    private static function z_SetContextDestructorCallback_ovr_0(context: cl_context; pfn_notify: ContextDestructorCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clSetContextDestructorCallback';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetContextDestructorCallback(context: cl_context; pfn_notify: ContextDestructorCallback; user_data: IntPtr): ErrorCode :=
    z_SetContextDestructorCallback_ovr_0(context, pfn_notify, user_data);
    
    // added in cl2.1
    private static function z_SetDefaultDeviceCommandQueue_ovr_0(context: cl_context; device: cl_device_id; command_queue: cl_command_queue): ErrorCode;
    external 'opencl' name 'clSetDefaultDeviceCommandQueue';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDefaultDeviceCommandQueue(context: cl_context; device: cl_device_id; command_queue: cl_command_queue): ErrorCode :=
    z_SetDefaultDeviceCommandQueue_ovr_0(context, device, command_queue);
    
    // added in cl1.1
    private static function z_SetEventCallback_ovr_0(&event: cl_event; command_exec_callback_type: CommandExecutionStatus; pfn_notify: EventCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clSetEventCallback';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetEventCallback(&event: cl_event; command_exec_callback_type: CommandExecutionStatus; pfn_notify: EventCallback; user_data: IntPtr): ErrorCode :=
    z_SetEventCallback_ovr_0(&event, command_exec_callback_type, pfn_notify, user_data);
    
    // added in cl1.0
    private static function z_SetKernelArg_ovr_0(kernel: cl_kernel; arg_index: UInt32; arg_size: UIntPtr; var arg_value: Byte): ErrorCode;
    external 'opencl' name 'clSetKernelArg';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelArg<T>(kernel: cl_kernel; arg_index: UInt32; arg_size: UIntPtr; var arg_value: T): ErrorCode; where T: record;
    begin
      Result := z_SetKernelArg_ovr_0(kernel, arg_index, arg_size, PByte(pointer(@arg_value))^);
    end;
    private static function z_SetKernelArg_ovr_1(kernel: cl_kernel; arg_index: UInt32; arg_size: UIntPtr; arg_value: pointer): ErrorCode;
    external 'opencl' name 'clSetKernelArg';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelArg(kernel: cl_kernel; arg_index: UInt32; arg_size: UIntPtr; arg_value: pointer): ErrorCode :=
    z_SetKernelArg_ovr_1(kernel, arg_index, arg_size, arg_value);
    
    // added in cl2.0
    private static function z_SetKernelArgSVMPointer_ovr_0(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetKernelArgSVMPointer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelArgSVMPointer(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode :=
    z_SetKernelArgSVMPointer_ovr_0(kernel, arg_index, arg_value);
    
    // added in cl2.0
    private static function z_SetKernelExecInfo_ovr_0(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; var param_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetKernelExecInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelExecInfo(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; var param_value: IntPtr): ErrorCode :=
    z_SetKernelExecInfo_ovr_0(kernel, param_name, param_value_size, param_value);
    private static function z_SetKernelExecInfo_ovr_1(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; var param_value: Bool): ErrorCode;
    external 'opencl' name 'clSetKernelExecInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelExecInfo(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; var param_value: Bool): ErrorCode :=
    z_SetKernelExecInfo_ovr_1(kernel, param_name, param_value_size, param_value);
    private static function z_SetKernelExecInfo_ovr_2(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; param_value: pointer): ErrorCode;
    external 'opencl' name 'clSetKernelExecInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelExecInfo(kernel: cl_kernel; param_name: KernelExecInfo; param_value_size: UIntPtr; param_value: pointer): ErrorCode :=
    z_SetKernelExecInfo_ovr_2(kernel, param_name, param_value_size, param_value);
    
    // added in cl1.1
    private static function z_SetMemObjectDestructorCallback_ovr_0(memobj: cl_mem; pfn_notify: MemObjectDestructorCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clSetMemObjectDestructorCallback';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetMemObjectDestructorCallback(memobj: cl_mem; pfn_notify: MemObjectDestructorCallback; user_data: IntPtr): ErrorCode :=
    z_SetMemObjectDestructorCallback_ovr_0(memobj, pfn_notify, user_data);
    
    // added in cl2.2
    private static function z_SetProgramReleaseCallback_ovr_0(&program: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clSetProgramReleaseCallback';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetProgramReleaseCallback(&program: cl_program; pfn_notify: ProgramCallback; user_data: IntPtr): ErrorCode :=
    z_SetProgramReleaseCallback_ovr_0(&program, pfn_notify, user_data);
    
    // added in cl2.2
    private static function z_SetProgramSpecializationConstant_ovr_0(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; var spec_value: Byte): ErrorCode;
    external 'opencl' name 'clSetProgramSpecializationConstant';
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_SetProgramSpecializationConstant_ovr_0<T>(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; var spec_value: T): ErrorCode; where T: record;
    begin
      Result := z_SetProgramSpecializationConstant_ovr_0(&program, spec_id, spec_size, PByte(pointer(@spec_value))^);
    end;
    private [MethodImpl(MethodImplOptions.AggressiveInlining)] static function temp_SetProgramSpecializationConstant_ovr_0_anh00001(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr): ErrorCode :=
    z_SetProgramSpecializationConstant_ovr_0(&program, spec_id, spec_size, PByte(nil)^);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetProgramSpecializationConstant<T>(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; spec_value: array of T): ErrorCode; where T: record;
    begin
      if (spec_value<>nil) and (spec_value.Length<>0) then
        Result := temp_SetProgramSpecializationConstant_ovr_0(&program, spec_id, spec_size, spec_value[0]) else
        Result := temp_SetProgramSpecializationConstant_ovr_0_anh00001(&program, spec_id, spec_size);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetProgramSpecializationConstant<T>(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; var spec_value: T): ErrorCode; where T: record;
    begin
      Result := z_SetProgramSpecializationConstant_ovr_0(&program, spec_id, spec_size, PByte(pointer(@spec_value))^);
    end;
    private static function z_SetProgramSpecializationConstant_ovr_2(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; spec_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetProgramSpecializationConstant';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetProgramSpecializationConstant(&program: cl_program; spec_id: UInt32; spec_size: UIntPtr; spec_value: IntPtr): ErrorCode :=
    z_SetProgramSpecializationConstant_ovr_2(&program, spec_id, spec_size, spec_value);
    
    // added in cl1.1
    private static function z_SetUserEventStatus_ovr_0(&event: cl_event; execution_status: CommandExecutionStatus): ErrorCode;
    external 'opencl' name 'clSetUserEventStatus';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetUserEventStatus(&event: cl_event; execution_status: CommandExecutionStatus): ErrorCode :=
    z_SetUserEventStatus_ovr_0(&event, execution_status);
    
    // added in cl2.0
    private static function z_SVMAlloc_ovr_0(context: cl_context; flags: SvmMemFlags; size: UIntPtr; alignment: UInt32): IntPtr;
    external 'opencl' name 'clSVMAlloc';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SVMAlloc(context: cl_context; flags: SvmMemFlags; size: UIntPtr; alignment: UInt32): IntPtr :=
    z_SVMAlloc_ovr_0(context, flags, size, alignment);
    
    // added in cl2.0
    private static procedure z_SVMFree_ovr_0(context: cl_context; svm_pointer: IntPtr);
    external 'opencl' name 'clSVMFree';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure SVMFree(context: cl_context; svm_pointer: IntPtr) :=
    z_SVMFree_ovr_0(context, svm_pointer);
    
    // added in cl1.0
    private static function z_UnloadCompiler_ovr_0: ErrorCode;
    external 'opencl' name 'clUnloadCompiler';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UnloadCompiler: ErrorCode :=
    z_UnloadCompiler_ovr_0;
    
    // added in cl1.2
    private static function z_UnloadPlatformCompiler_ovr_0(platform: cl_platform_id): ErrorCode;
    external 'opencl' name 'clUnloadPlatformCompiler';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UnloadPlatformCompiler(platform: cl_platform_id): ErrorCode :=
    z_UnloadPlatformCompiler_ovr_0(platform);
    
    // added in cl1.0
    private static function z_WaitForEvents_ovr_0(num_events: UInt32; var event_list: cl_event): ErrorCode;
    external 'opencl' name 'clWaitForEvents';
    private static function z_WaitForEvents_ovr_0_anh001(num_events: UInt32; event_list: IntPtr): ErrorCode;
    external 'opencl' name 'clWaitForEvents';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForEvents(num_events: UInt32; event_list: array of cl_event): ErrorCode :=
    if (event_list<>nil) and (event_list.Length<>0) then
      z_WaitForEvents_ovr_0(num_events, event_list[0]) else
      z_WaitForEvents_ovr_0_anh001(num_events, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForEvents(num_events: UInt32; var event_list: cl_event): ErrorCode :=
    z_WaitForEvents_ovr_0(num_events, event_list);
    private static function z_WaitForEvents_ovr_2(num_events: UInt32; event_list: IntPtr): ErrorCode;
    external 'opencl' name 'clWaitForEvents';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForEvents(num_events: UInt32; event_list: IntPtr): ErrorCode :=
    z_WaitForEvents_ovr_2(num_events, event_list);
    
  end;
  
  {$region Extensions}
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clD3d10SharingKHR = static class
    public const _ExtStr = 'khr_d3d10_sharing';
    
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_0(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000010(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000001(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000011(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromD3D10KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000011(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_1_anh00000010(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromD3D10KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_2(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_2_anh00000010(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromD3D10KHR_ovr_2(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromD3D10KHR_ovr_2_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromD3D10KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromD3D10KHR_ovr_0_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromD3D10KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromD3D10KHR_ovr_2(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_6(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_6_anh00000001(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromD3D10KHR_ovr_6(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromD3D10KHR_ovr_6_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromD3D10KHR_ovr_6(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromD3D10KHR_ovr_8(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D10KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D10KHR(platform: cl_platform_id; d3d_device_source: D3d10DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d10DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromD3D10KHR_ovr_8(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    
    private static function z_CreateFromD3D10BufferKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10BufferKHR';
    private static function z_CreateFromD3D10BufferKHR_ovr_0_anh00010(context: cl_context; flags: MemFlags; resource: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10BufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10BufferKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D10BufferKHR_ovr_0(context, flags, resource[0], errcode_ret) else
      z_CreateFromD3D10BufferKHR_ovr_0_anh00010(context, flags, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10BufferKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10BufferKHR_ovr_0(context, flags, resource, errcode_ret);
    private static function z_CreateFromD3D10BufferKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10BufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10BufferKHR(context: cl_context; flags: MemFlags; resource: pointer; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10BufferKHR_ovr_2(context, flags, resource, errcode_ret);
    
    private static function z_CreateFromD3D10Texture2DKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture2DKHR';
    private static function z_CreateFromD3D10Texture2DKHR_ovr_0_anh000100(context: cl_context; flags: MemFlags; resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture2DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture2DKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D10Texture2DKHR_ovr_0(context, flags, resource[0], subresource, errcode_ret) else
      z_CreateFromD3D10Texture2DKHR_ovr_0_anh000100(context, flags, IntPtr.Zero, subresource, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture2DKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10Texture2DKHR_ovr_0(context, flags, resource, subresource, errcode_ret);
    private static function z_CreateFromD3D10Texture2DKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture2DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture2DKHR(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10Texture2DKHR_ovr_2(context, flags, resource, subresource, errcode_ret);
    
    private static function z_CreateFromD3D10Texture3DKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture3DKHR';
    private static function z_CreateFromD3D10Texture3DKHR_ovr_0_anh000100(context: cl_context; flags: MemFlags; resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture3DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture3DKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D10Texture3DKHR_ovr_0(context, flags, resource[0], subresource, errcode_ret) else
      z_CreateFromD3D10Texture3DKHR_ovr_0_anh000100(context, flags, IntPtr.Zero, subresource, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture3DKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10Texture3DKHR_ovr_0(context, flags, resource, subresource, errcode_ret);
    private static function z_CreateFromD3D10Texture3DKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D10Texture3DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D10Texture3DKHR(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D10Texture3DKHR_ovr_2(context, flags, resource, subresource, errcode_ret);
    
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D10ObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D10ObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D10ObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D10ObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D10ObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D10ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D10ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D10ObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clD3d11SharingKHR = static class
    public const _ExtStr = 'khr_d3d11_sharing';
    
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_0(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000010(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000001(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000011(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromD3D11KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000011(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_1_anh00000010(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromD3D11KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_2(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_2_anh00000010(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromD3D11KHR_ovr_2(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromD3D11KHR_ovr_2_anh00000010(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromD3D11KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromD3D11KHR_ovr_0_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromD3D11KHR_ovr_0(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromD3D11KHR_ovr_2(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_6(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_6_anh00000001(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromD3D11KHR_ovr_6(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromD3D11KHR_ovr_6_anh00000001(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromD3D11KHR_ovr_6(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromD3D11KHR_ovr_8(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromD3D11KHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromD3D11KHR(platform: cl_platform_id; d3d_device_source: D3d11DeviceSourceKhr; d3d_object: IntPtr; d3d_device_set: D3d11DeviceSetKhr; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromD3D11KHR_ovr_8(platform, d3d_device_source, d3d_object, d3d_device_set, num_entries, devices, num_devices);
    
    private static function z_CreateFromD3D11BufferKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11BufferKHR';
    private static function z_CreateFromD3D11BufferKHR_ovr_0_anh00010(context: cl_context; flags: MemFlags; resource: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11BufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11BufferKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D11BufferKHR_ovr_0(context, flags, resource[0], errcode_ret) else
      z_CreateFromD3D11BufferKHR_ovr_0_anh00010(context, flags, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11BufferKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11BufferKHR_ovr_0(context, flags, resource, errcode_ret);
    private static function z_CreateFromD3D11BufferKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11BufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11BufferKHR(context: cl_context; flags: MemFlags; resource: pointer; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11BufferKHR_ovr_2(context, flags, resource, errcode_ret);
    
    private static function z_CreateFromD3D11Texture2DKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture2DKHR';
    private static function z_CreateFromD3D11Texture2DKHR_ovr_0_anh000100(context: cl_context; flags: MemFlags; resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture2DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture2DKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D11Texture2DKHR_ovr_0(context, flags, resource[0], subresource, errcode_ret) else
      z_CreateFromD3D11Texture2DKHR_ovr_0_anh000100(context, flags, IntPtr.Zero, subresource, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture2DKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11Texture2DKHR_ovr_0(context, flags, resource, subresource, errcode_ret);
    private static function z_CreateFromD3D11Texture2DKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture2DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture2DKHR(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11Texture2DKHR_ovr_2(context, flags, resource, subresource, errcode_ret);
    
    private static function z_CreateFromD3D11Texture3DKHR_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture3DKHR';
    private static function z_CreateFromD3D11Texture3DKHR_ovr_0_anh000100(context: cl_context; flags: MemFlags; resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture3DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture3DKHR(context: cl_context; flags: MemFlags; resource: array of IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromD3D11Texture3DKHR_ovr_0(context, flags, resource[0], subresource, errcode_ret) else
      z_CreateFromD3D11Texture3DKHR_ovr_0_anh000100(context, flags, IntPtr.Zero, subresource, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture3DKHR(context: cl_context; flags: MemFlags; var resource: IntPtr; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11Texture3DKHR_ovr_0(context, flags, resource, subresource, errcode_ret);
    private static function z_CreateFromD3D11Texture3DKHR_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromD3D11Texture3DKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromD3D11Texture3DKHR(context: cl_context; flags: MemFlags; resource: pointer; subresource: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromD3D11Texture3DKHR_ovr_2(context, flags, resource, subresource, errcode_ret);
    
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireD3D11ObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireD3D11ObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireD3D11ObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseD3D11ObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseD3D11ObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseD3D11ObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseD3D11ObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseD3D11ObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clDx9MediaSharingKHR = static class
    public const _ExtStr = 'khr_dx9_media_sharing';
    
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000001(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100001(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000011(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100011(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      if (devices<>nil) and (devices.Length<>0) then
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices[0], num_devices[0]) else
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000001(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices[0], IntPtr.Zero) else
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000010(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices[0]) else
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000011(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, IntPtr.Zero, IntPtr.Zero) else
      if (devices<>nil) and (devices.Length<>0) then
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices[0], num_devices[0]) else
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100001(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices[0], IntPtr.Zero) else
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100010(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices[0]) else
          z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100011(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_1_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_1_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_1_anh000100010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      if (devices<>nil) and (devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000010(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices) else
      if (devices<>nil) and (devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100010(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000100010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      if (devices<>nil) and (devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000000010(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices) else
      if (devices<>nil) and (devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000100010(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_3_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_3_anh000100001(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000001(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100001(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_4_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_5_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000000001(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000100001(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000000001(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000100001(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_7_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_8(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_8_anh000100000(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: array of UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    if (media_adapter_type<>nil) and (media_adapter_type.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_8(platform, num_media_adapters, media_adapter_type[0], media_adapters, media_adapter_set, num_entries, devices, num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_8_anh000100000(platform, num_media_adapters, IntPtr.Zero, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000011(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_0(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_2(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_6(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; var media_adapter_type: UInt32; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_8(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000001(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000011(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000011(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_19_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_20(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_20_anh000000010(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_20(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_20_anh000000010(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_18(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_20(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_24(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_24_anh000000001(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_24(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_24_anh000000001(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_24(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_26(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9MediaAdapterKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9MediaAdapterKHR(platform: cl_platform_id; num_media_adapters: UInt32; media_adapter_type: IntPtr; media_adapters: IntPtr; media_adapter_set: UInt32; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9MediaAdapterKHR_ovr_26(platform, num_media_adapters, media_adapter_type, media_adapters, media_adapter_set, num_entries, devices, num_devices);
    
    private static function z_CreateFromDX9MediaSurfaceKHR_ovr_0(context: cl_context; flags: MemFlags; adapter_type: UInt32; surface_info: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromDX9MediaSurfaceKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromDX9MediaSurfaceKHR(context: cl_context; flags: MemFlags; adapter_type: UInt32; surface_info: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromDX9MediaSurfaceKHR_ovr_0(context, flags, adapter_type, surface_info, plane, errcode_ret);
    
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9MediaSurfacesKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9MediaSurfacesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9MediaSurfacesKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9MediaSurfacesKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clEglImageKHR = static class
    public const _ExtStr = 'khr_egl_image';
    
    private static function z_CreateFromEGLImageKHR_ovr_0(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; var properties: EglImagePropertiesKhr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromEGLImageKHR';
    private static function z_CreateFromEGLImageKHR_ovr_0_anh0000010(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; properties: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromEGLImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromEGLImageKHR(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; properties: array of EglImagePropertiesKhr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateFromEGLImageKHR_ovr_0(context, egldisplay, eglimage, flags, properties[0], errcode_ret) else
      z_CreateFromEGLImageKHR_ovr_0_anh0000010(context, egldisplay, eglimage, flags, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromEGLImageKHR(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; var properties: EglImagePropertiesKhr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromEGLImageKHR_ovr_0(context, egldisplay, eglimage, flags, properties, errcode_ret);
    private static function z_CreateFromEGLImageKHR_ovr_2(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; properties: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromEGLImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromEGLImageKHR(context: cl_context; egldisplay: IntPtr; eglimage: IntPtr; flags: MemFlags; properties: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromEGLImageKHR_ovr_2(context, egldisplay, eglimage, flags, properties, errcode_ret);
    
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireEGLObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireEGLObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireEGLObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireEGLObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseEGLObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseEGLObjectsKHR_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseEGLObjectsKHR_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseEGLObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseEGLObjectsKHR(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseEGLObjectsKHR_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clEglEventKHR = static class
    public const _ExtStr = 'khr_egl_event';
    
    private static function z_CreateEventFromEGLSyncKHR_ovr_0(context: cl_context; sync: IntPtr; display: IntPtr; var errcode_ret: ErrorCode): cl_event;
    external 'opencl' name 'clCreateEventFromEGLSyncKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateEventFromEGLSyncKHR(context: cl_context; sync: IntPtr; display: IntPtr; var errcode_ret: ErrorCode): cl_event :=
    z_CreateEventFromEGLSyncKHR_ovr_0(context, sync, display, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSetMemObjectDestructorAPPLE = static class
    public const _ExtStr = 'APPLE_SetMemObjectDestructor';
    
    private static function z_SetMemObjectDestructorAPPLE_ovr_0(memobj: cl_mem; pfn_notify: MemObjectDestructorCallback; user_data: IntPtr): ErrorCode;
    external 'opencl' name 'clSetMemObjectDestructorAPPLE';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetMemObjectDestructorAPPLE(memobj: cl_mem; pfn_notify: MemObjectDestructorCallback; user_data: IntPtr): ErrorCode :=
    z_SetMemObjectDestructorAPPLE_ovr_0(memobj, pfn_notify, user_data);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clContextLoggingFunctionsAPPLE = static class
    public const _ExtStr = 'APPLE_ContextLoggingFunctions';
    
    private static procedure z_LogMessagesToSystemLogAPPLE_ovr_0(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    external 'opencl' name 'clLogMessagesToSystemLogAPPLE';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToSystemLogAPPLE(errstr: string; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    begin
      var par_1_str_ptr: IntPtr;
      try
        par_1_str_ptr := Marshal.StringToHGlobalAnsi(errstr);
        z_LogMessagesToSystemLogAPPLE_ovr_0(par_1_str_ptr, private_info, cb, user_data);
      finally
        Marshal.FreeHGlobal(par_1_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToSystemLogAPPLE(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr) :=
    z_LogMessagesToSystemLogAPPLE_ovr_0(errstr, private_info, cb, user_data);
    
    private static procedure z_LogMessagesToStdoutAPPLE_ovr_0(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    external 'opencl' name 'clLogMessagesToStdoutAPPLE';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToStdoutAPPLE(errstr: string; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    begin
      var par_1_str_ptr: IntPtr;
      try
        par_1_str_ptr := Marshal.StringToHGlobalAnsi(errstr);
        z_LogMessagesToStdoutAPPLE_ovr_0(par_1_str_ptr, private_info, cb, user_data);
      finally
        Marshal.FreeHGlobal(par_1_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToStdoutAPPLE(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr) :=
    z_LogMessagesToStdoutAPPLE_ovr_0(errstr, private_info, cb, user_data);
    
    private static procedure z_LogMessagesToStderrAPPLE_ovr_0(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    external 'opencl' name 'clLogMessagesToStderrAPPLE';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToStderrAPPLE(errstr: string; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr);
    begin
      var par_1_str_ptr: IntPtr;
      try
        par_1_str_ptr := Marshal.StringToHGlobalAnsi(errstr);
        z_LogMessagesToStderrAPPLE_ovr_0(par_1_str_ptr, private_info, cb, user_data);
      finally
        Marshal.FreeHGlobal(par_1_str_ptr);
      end;
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure LogMessagesToStderrAPPLE(errstr: IntPtr; private_info: IntPtr; cb: UIntPtr; user_data: IntPtr) :=
    z_LogMessagesToStderrAPPLE_ovr_0(errstr, private_info, cb, user_data);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clIcdKHR = static class
    public const _ExtStr = 'khr_icd';
    
    private static function z_IcdGetPlatformIDsKHR_ovr_0(num_entries: UInt32; var platforms: cl_platform_id; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    private static function z_IcdGetPlatformIDsKHR_ovr_0_anh0010(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    private static function z_IcdGetPlatformIDsKHR_ovr_0_anh0001(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    private static function z_IcdGetPlatformIDsKHR_ovr_0_anh0011(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: array of cl_platform_id; num_platforms: array of UInt32): ErrorCode :=
    if (platforms<>nil) and (platforms.Length<>0) then
      if (num_platforms<>nil) and (num_platforms.Length<>0) then
        z_IcdGetPlatformIDsKHR_ovr_0(num_entries, platforms[0], num_platforms[0]) else
        z_IcdGetPlatformIDsKHR_ovr_0_anh0001(num_entries, platforms[0], IntPtr.Zero) else
      if (num_platforms<>nil) and (num_platforms.Length<>0) then
        z_IcdGetPlatformIDsKHR_ovr_0_anh0010(num_entries, IntPtr.Zero, num_platforms[0]) else
        z_IcdGetPlatformIDsKHR_ovr_0_anh0011(num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_IcdGetPlatformIDsKHR_ovr_1_anh0010(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: array of cl_platform_id; var num_platforms: UInt32): ErrorCode :=
    if (platforms<>nil) and (platforms.Length<>0) then
      z_IcdGetPlatformIDsKHR_ovr_0(num_entries, platforms[0], num_platforms) else
      z_IcdGetPlatformIDsKHR_ovr_0_anh0010(num_entries, IntPtr.Zero, num_platforms);
    private static function z_IcdGetPlatformIDsKHR_ovr_2(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    private static function z_IcdGetPlatformIDsKHR_ovr_2_anh0010(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: array of cl_platform_id; num_platforms: IntPtr): ErrorCode :=
    if (platforms<>nil) and (platforms.Length<>0) then
      z_IcdGetPlatformIDsKHR_ovr_2(num_entries, platforms[0], num_platforms) else
      z_IcdGetPlatformIDsKHR_ovr_2_anh0010(num_entries, IntPtr.Zero, num_platforms);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: array of UInt32): ErrorCode :=
    if (num_platforms<>nil) and (num_platforms.Length<>0) then
      z_IcdGetPlatformIDsKHR_ovr_0(num_entries, platforms, num_platforms[0]) else
      z_IcdGetPlatformIDsKHR_ovr_0_anh0001(num_entries, platforms, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; var platforms: cl_platform_id; var num_platforms: UInt32): ErrorCode :=
    z_IcdGetPlatformIDsKHR_ovr_0(num_entries, platforms, num_platforms);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; var platforms: cl_platform_id; num_platforms: IntPtr): ErrorCode :=
    z_IcdGetPlatformIDsKHR_ovr_2(num_entries, platforms, num_platforms);
    private static function z_IcdGetPlatformIDsKHR_ovr_6(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    private static function z_IcdGetPlatformIDsKHR_ovr_6_anh0001(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: IntPtr; num_platforms: array of UInt32): ErrorCode :=
    if (num_platforms<>nil) and (num_platforms.Length<>0) then
      z_IcdGetPlatformIDsKHR_ovr_6(num_entries, platforms, num_platforms[0]) else
      z_IcdGetPlatformIDsKHR_ovr_6_anh0001(num_entries, platforms, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: IntPtr; var num_platforms: UInt32): ErrorCode :=
    z_IcdGetPlatformIDsKHR_ovr_6(num_entries, platforms, num_platforms);
    private static function z_IcdGetPlatformIDsKHR_ovr_8(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode;
    external 'opencl' name 'clIcdGetPlatformIDsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IcdGetPlatformIDsKHR(num_entries: UInt32; platforms: IntPtr; num_platforms: IntPtr): ErrorCode :=
    z_IcdGetPlatformIDsKHR_ovr_8(num_entries, platforms, num_platforms);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clLoaderLayers = static class
    public const _ExtStr = 'loader_layers';
    
    private static function z_GetLayerInfo_ovr_0(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetLayerInfo';
    private static function z_GetLayerInfo_ovr_0_anh00001(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetLayerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerInfo(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetLayerInfo_ovr_0(param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetLayerInfo_ovr_0_anh00001(param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerInfo(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetLayerInfo_ovr_0(param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetLayerInfo_ovr_2(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetLayerInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerInfo(param_name: LayerInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetLayerInfo_ovr_2(param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_InitLayer_ovr_0(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; var layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    private static function z_InitLayer_ovr_0_anh00010(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; var layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    private static function z_InitLayer_ovr_0_anh00001(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    private static function z_InitLayer_ovr_0_anh00011(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: array of UInt32; layer_dispatch: array of IntPtr): ErrorCode :=
    if (num_entries_ret<>nil) and (num_entries_ret.Length<>0) then
      if (layer_dispatch<>nil) and (layer_dispatch.Length<>0) then
        z_InitLayer_ovr_0(num_entries, target_dispatch, num_entries_ret[0], layer_dispatch[0]) else
        z_InitLayer_ovr_0_anh00001(num_entries, target_dispatch, num_entries_ret[0], IntPtr.Zero) else
      if (layer_dispatch<>nil) and (layer_dispatch.Length<>0) then
        z_InitLayer_ovr_0_anh00010(num_entries, target_dispatch, IntPtr.Zero, layer_dispatch[0]) else
        z_InitLayer_ovr_0_anh00011(num_entries, target_dispatch, IntPtr.Zero, IntPtr.Zero);
    private static function z_InitLayer_ovr_1_anh00010(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; var layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: array of UInt32; var layer_dispatch: IntPtr): ErrorCode :=
    if (num_entries_ret<>nil) and (num_entries_ret.Length<>0) then
      z_InitLayer_ovr_0(num_entries, target_dispatch, num_entries_ret[0], layer_dispatch) else
      z_InitLayer_ovr_0_anh00010(num_entries, target_dispatch, IntPtr.Zero, layer_dispatch);
    private static function z_InitLayer_ovr_2(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; layer_dispatch: pointer): ErrorCode;
    external 'opencl' name 'clInitLayer';
    private static function z_InitLayer_ovr_2_anh00010(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: pointer): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: array of UInt32; layer_dispatch: pointer): ErrorCode :=
    if (num_entries_ret<>nil) and (num_entries_ret.Length<>0) then
      z_InitLayer_ovr_2(num_entries, target_dispatch, num_entries_ret[0], layer_dispatch) else
      z_InitLayer_ovr_2_anh00010(num_entries, target_dispatch, IntPtr.Zero, layer_dispatch);
    private static function z_InitLayer_ovr_3_anh00001(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; layer_dispatch: array of IntPtr): ErrorCode :=
    if (layer_dispatch<>nil) and (layer_dispatch.Length<>0) then
      z_InitLayer_ovr_0(num_entries, target_dispatch, num_entries_ret, layer_dispatch[0]) else
      z_InitLayer_ovr_0_anh00001(num_entries, target_dispatch, num_entries_ret, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; var layer_dispatch: IntPtr): ErrorCode :=
    z_InitLayer_ovr_0(num_entries, target_dispatch, num_entries_ret, layer_dispatch);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; var num_entries_ret: UInt32; layer_dispatch: pointer): ErrorCode :=
    z_InitLayer_ovr_2(num_entries, target_dispatch, num_entries_ret, layer_dispatch);
    private static function z_InitLayer_ovr_6(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; var layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    private static function z_InitLayer_ovr_6_anh00001(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: IntPtr): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: array of IntPtr): ErrorCode :=
    if (layer_dispatch<>nil) and (layer_dispatch.Length<>0) then
      z_InitLayer_ovr_6(num_entries, target_dispatch, num_entries_ret, layer_dispatch[0]) else
      z_InitLayer_ovr_6_anh00001(num_entries, target_dispatch, num_entries_ret, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; var layer_dispatch: IntPtr): ErrorCode :=
    z_InitLayer_ovr_6(num_entries, target_dispatch, num_entries_ret, layer_dispatch);
    private static function z_InitLayer_ovr_8(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: pointer): ErrorCode;
    external 'opencl' name 'clInitLayer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function InitLayer(num_entries: UInt32; target_dispatch: IntPtr; num_entries_ret: IntPtr; layer_dispatch: pointer): ErrorCode :=
    z_InitLayer_ovr_8(num_entries, target_dispatch, num_entries_ret, layer_dispatch);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clIlProgramKHR = static class
    public const _ExtStr = 'khr_il_program';
    
    private static function z_CreateProgramWithILKHR_ovr_0(context: cl_context; var il: byte; length: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithILKHR';
    private static function z_CreateProgramWithILKHR_ovr_0_anh00100(context: cl_context; il: IntPtr; length: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithILKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithILKHR(context: cl_context; il: array of byte; length: UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    if (il<>nil) and (il.Length<>0) then
      z_CreateProgramWithILKHR_ovr_0(context, il[0], length, errcode_ret) else
      z_CreateProgramWithILKHR_ovr_0_anh00100(context, IntPtr.Zero, length, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithILKHR(context: cl_context; var il: byte; length: UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithILKHR_ovr_0(context, il, length, errcode_ret);
    private static function z_CreateProgramWithILKHR_ovr_2(context: cl_context; il: IntPtr; length: UIntPtr; var errcode_ret: ErrorCode): cl_program;
    external 'opencl' name 'clCreateProgramWithILKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateProgramWithILKHR(context: cl_context; il: IntPtr; length: UIntPtr; var errcode_ret: ErrorCode): cl_program :=
    z_CreateProgramWithILKHR_ovr_2(context, il, length, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clTerminateContextKHR = static class
    public const _ExtStr = 'khr_terminate_context';
    
    private static function z_TerminateContextKHR_ovr_0(context: cl_context): ErrorCode;
    external 'opencl' name 'clTerminateContextKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function TerminateContextKHR(context: cl_context): ErrorCode :=
    z_TerminateContextKHR_ovr_0(context);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clCreateCommandQueueKHR = static class
    public const _ExtStr = 'khr_create_command_queue';
    
    private static function z_CreateCommandQueueWithPropertiesKHR_ovr_0(context: cl_context; device: cl_device_id; var properties: UInt64; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithPropertiesKHR';
    private static function z_CreateCommandQueueWithPropertiesKHR_ovr_0_anh00010(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithPropertiesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithPropertiesKHR(context: cl_context; device: cl_device_id; properties: array of UInt64; var errcode_ret: ErrorCode): cl_command_queue :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateCommandQueueWithPropertiesKHR_ovr_0(context, device, properties[0], errcode_ret) else
      z_CreateCommandQueueWithPropertiesKHR_ovr_0_anh00010(context, device, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithPropertiesKHR(context: cl_context; device: cl_device_id; var properties: UInt64; var errcode_ret: ErrorCode): cl_command_queue :=
    z_CreateCommandQueueWithPropertiesKHR_ovr_0(context, device, properties, errcode_ret);
    private static function z_CreateCommandQueueWithPropertiesKHR_ovr_2(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue;
    external 'opencl' name 'clCreateCommandQueueWithPropertiesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandQueueWithPropertiesKHR(context: cl_context; device: cl_device_id; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_queue :=
    z_CreateCommandQueueWithPropertiesKHR_ovr_2(context, device, properties, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clDeviceFissionEXT = static class
    public const _ExtStr = 'ext_device_fission';
    
    private static function z_ReleaseDeviceEXT_ovr_0(device: cl_device_id): ErrorCode;
    external 'opencl' name 'clReleaseDeviceEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseDeviceEXT(device: cl_device_id): ErrorCode :=
    z_ReleaseDeviceEXT_ovr_0(device);
    
    private static function z_RetainDeviceEXT_ovr_0(device: cl_device_id): ErrorCode;
    external 'opencl' name 'clRetainDeviceEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainDeviceEXT(device: cl_device_id): ErrorCode :=
    z_RetainDeviceEXT_ovr_0(device);
    
    private static function z_CreateSubDevicesEXT_ovr_0(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh000010(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh001010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh000001(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh001001(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh000011(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_0_anh001011(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (out_devices<>nil) and (out_devices.Length<>0) then
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_CreateSubDevicesEXT_ovr_0(in_device, properties[0], num_entries, out_devices[0], num_devices[0]) else
          z_CreateSubDevicesEXT_ovr_0_anh000001(in_device, properties[0], num_entries, out_devices[0], IntPtr.Zero) else
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_CreateSubDevicesEXT_ovr_0_anh000010(in_device, properties[0], num_entries, IntPtr.Zero, num_devices[0]) else
          z_CreateSubDevicesEXT_ovr_0_anh000011(in_device, properties[0], num_entries, IntPtr.Zero, IntPtr.Zero) else
      if (out_devices<>nil) and (out_devices.Length<>0) then
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_CreateSubDevicesEXT_ovr_0_anh001000(in_device, IntPtr.Zero, num_entries, out_devices[0], num_devices[0]) else
          z_CreateSubDevicesEXT_ovr_0_anh001001(in_device, IntPtr.Zero, num_entries, out_devices[0], IntPtr.Zero) else
        if (num_devices<>nil) and (num_devices.Length<>0) then
          z_CreateSubDevicesEXT_ovr_0_anh001010(in_device, IntPtr.Zero, num_entries, IntPtr.Zero, num_devices[0]) else
          z_CreateSubDevicesEXT_ovr_0_anh001011(in_device, IntPtr.Zero, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_CreateSubDevicesEXT_ovr_1_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_1_anh000010(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_1_anh001010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (out_devices<>nil) and (out_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0(in_device, properties[0], num_entries, out_devices[0], num_devices) else
        z_CreateSubDevicesEXT_ovr_0_anh000010(in_device, properties[0], num_entries, IntPtr.Zero, num_devices) else
      if (out_devices<>nil) and (out_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0_anh001000(in_device, IntPtr.Zero, num_entries, out_devices[0], num_devices) else
        z_CreateSubDevicesEXT_ovr_0_anh001010(in_device, IntPtr.Zero, num_entries, IntPtr.Zero, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_2(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_2_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_2_anh000010(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_2_anh001010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (out_devices<>nil) and (out_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_2(in_device, properties[0], num_entries, out_devices[0], num_devices) else
        z_CreateSubDevicesEXT_ovr_2_anh000010(in_device, properties[0], num_entries, IntPtr.Zero, num_devices) else
      if (out_devices<>nil) and (out_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_2_anh001000(in_device, IntPtr.Zero, num_entries, out_devices[0], num_devices) else
        z_CreateSubDevicesEXT_ovr_2_anh001010(in_device, IntPtr.Zero, num_entries, IntPtr.Zero, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_3_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_3_anh001001(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0(in_device, properties[0], num_entries, out_devices, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_0_anh000001(in_device, properties[0], num_entries, out_devices, IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_0_anh001001(in_device, IntPtr.Zero, num_entries, out_devices, IntPtr.Zero);
    private static function z_CreateSubDevicesEXT_ovr_4_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevicesEXT_ovr_0(in_device, properties[0], num_entries, out_devices, num_devices) else
      z_CreateSubDevicesEXT_ovr_0_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_5_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevicesEXT_ovr_2(in_device, properties[0], num_entries, out_devices, num_devices) else
      z_CreateSubDevicesEXT_ovr_2_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_6(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_6_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_6_anh000001(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_6_anh001001(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_6(in_device, properties[0], num_entries, out_devices, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_6_anh000001(in_device, properties[0], num_entries, out_devices, IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_6_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_6_anh001001(in_device, IntPtr.Zero, num_entries, out_devices, IntPtr.Zero);
    private static function z_CreateSubDevicesEXT_ovr_7_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevicesEXT_ovr_6(in_device, properties[0], num_entries, out_devices, num_devices) else
      z_CreateSubDevicesEXT_ovr_6_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_8(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_8_anh001000(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: array of DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateSubDevicesEXT_ovr_8(in_device, properties[0], num_entries, out_devices, num_devices) else
      z_CreateSubDevicesEXT_ovr_8_anh001000(in_device, IntPtr.Zero, num_entries, out_devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0(in_device, properties, num_entries, out_devices[0], num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_0_anh000001(in_device, properties, num_entries, out_devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_0_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_0_anh000011(in_device, properties, num_entries, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_0(in_device, properties, num_entries, out_devices[0], num_devices) else
      z_CreateSubDevicesEXT_ovr_0_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_2(in_device, properties, num_entries, out_devices[0], num_devices) else
      z_CreateSubDevicesEXT_ovr_2_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_0(in_device, properties, num_entries, out_devices, num_devices[0]) else
      z_CreateSubDevicesEXT_ovr_0_anh000001(in_device, properties, num_entries, out_devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_0(in_device, properties, num_entries, out_devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_2(in_device, properties, num_entries, out_devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_6(in_device, properties, num_entries, out_devices, num_devices[0]) else
      z_CreateSubDevicesEXT_ovr_6_anh000001(in_device, properties, num_entries, out_devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_6(in_device, properties, num_entries, out_devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; var properties: DevicePartitionPropertyExt; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_8(in_device, properties, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_18(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_18_anh000010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_18_anh000001(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_18_anh000011(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_18(in_device, properties, num_entries, out_devices[0], num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_18_anh000001(in_device, properties, num_entries, out_devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_CreateSubDevicesEXT_ovr_18_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices[0]) else
        z_CreateSubDevicesEXT_ovr_18_anh000011(in_device, properties, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_CreateSubDevicesEXT_ovr_19_anh000010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_18(in_device, properties, num_entries, out_devices[0], num_devices) else
      z_CreateSubDevicesEXT_ovr_18_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_20(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_20_anh000010(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (out_devices<>nil) and (out_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_20(in_device, properties, num_entries, out_devices[0], num_devices) else
      z_CreateSubDevicesEXT_ovr_20_anh000010(in_device, properties, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_18(in_device, properties, num_entries, out_devices, num_devices[0]) else
      z_CreateSubDevicesEXT_ovr_18_anh000001(in_device, properties, num_entries, out_devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_18(in_device, properties, num_entries, out_devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; var out_devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_20(in_device, properties, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_24(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    private static function z_CreateSubDevicesEXT_ovr_24_anh000001(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_CreateSubDevicesEXT_ovr_24(in_device, properties, num_entries, out_devices, num_devices[0]) else
      z_CreateSubDevicesEXT_ovr_24_anh000001(in_device, properties, num_entries, out_devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_24(in_device, properties, num_entries, out_devices, num_devices);
    private static function z_CreateSubDevicesEXT_ovr_26(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clCreateSubDevicesEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSubDevicesEXT(in_device: cl_device_id; properties: IntPtr; num_entries: UInt32; out_devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_CreateSubDevicesEXT_ovr_26(in_device, properties, num_entries, out_devices, num_devices);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clMigrateMemobjectEXT = static class
    public const _ExtStr = 'ext_migrate_memobject';
    
    private static function z_EnqueueMigrateMemObjectEXT_ovr_0(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_0_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_0_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_0_anh00010010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjectEXT_ovr_0(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjectEXT_ovr_0_anh00000010(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjectEXT_ovr_0_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjectEXT_ovr_0_anh00010010(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_1(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_1_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_1_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_1_anh00010010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjectEXT_ovr_1(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjectEXT_ovr_1_anh00000010(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueMigrateMemObjectEXT_ovr_1_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueMigrateMemObjectEXT_ovr_1_anh00010010(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_2_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_0(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_0_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_3_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_1(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_1_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_4(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_4_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_4(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_4_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_5(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_5_anh00010000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_5(command_queue, num_mem_objects, mem_objects[0], flags, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_5_anh00010000(command_queue, num_mem_objects, IntPtr.Zero, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_0(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_0_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_1(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_1_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_0(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_1(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_4(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_5(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_12(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_12_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_12(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_12_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_13(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    private static function z_EnqueueMigrateMemObjectEXT_ovr_13_anh00000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemObjectEXT_ovr_13(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemObjectEXT_ovr_13_anh00000010(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_12(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_13(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_16(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_16(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemObjectEXT_ovr_17(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemObjectEXT';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemObjectEXT(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; flags: MemMigrationFlagsExt; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemObjectEXT_ovr_17(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clExtHostPtrQCOM = static class
    public const _ExtStr = 'qcom_ext_host_ptr';
    
    private static function z_GetDeviceImageInfoQCOM_ovr_0(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    private static function z_GetDeviceImageInfoQCOM_ovr_0_anh000010000(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    private static function z_GetDeviceImageInfoQCOM_ovr_0_anh000000001(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    private static function z_GetDeviceImageInfoQCOM_ovr_0_anh000010001(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: array of cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (image_format<>nil) and (image_format.Length<>0) then
      if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
        z_GetDeviceImageInfoQCOM_ovr_0(device, image_width, image_height, image_format[0], param_name, param_value_size, param_value, param_value_size_ret[0]) else
        z_GetDeviceImageInfoQCOM_ovr_0_anh000000001(device, image_width, image_height, image_format[0], param_name, param_value_size, param_value, IntPtr.Zero) else
      if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
        z_GetDeviceImageInfoQCOM_ovr_0_anh000010000(device, image_width, image_height, IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret[0]) else
        z_GetDeviceImageInfoQCOM_ovr_0_anh000010001(device, image_width, image_height, IntPtr.Zero, param_name, param_value_size, param_value, IntPtr.Zero);
    private static function z_GetDeviceImageInfoQCOM_ovr_1_anh000010000(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: array of cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_GetDeviceImageInfoQCOM_ovr_0(device, image_width, image_height, image_format[0], param_name, param_value_size, param_value, param_value_size_ret) else
      z_GetDeviceImageInfoQCOM_ovr_0_anh000010000(device, image_width, image_height, IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceImageInfoQCOM_ovr_2(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    private static function z_GetDeviceImageInfoQCOM_ovr_2_anh000010000(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: array of cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    if (image_format<>nil) and (image_format.Length<>0) then
      z_GetDeviceImageInfoQCOM_ovr_2(device, image_width, image_height, image_format[0], param_name, param_value_size, param_value, param_value_size_ret) else
      z_GetDeviceImageInfoQCOM_ovr_2_anh000010000(device, image_width, image_height, IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetDeviceImageInfoQCOM_ovr_0(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetDeviceImageInfoQCOM_ovr_0_anh000000001(device, image_width, image_height, image_format, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceImageInfoQCOM_ovr_0(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; var image_format: cl_image_format; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceImageInfoQCOM_ovr_2(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceImageInfoQCOM_ovr_6(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    private static function z_GetDeviceImageInfoQCOM_ovr_6_anh000000001(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetDeviceImageInfoQCOM_ovr_6(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetDeviceImageInfoQCOM_ovr_6_anh000000001(device, image_width, image_height, image_format, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetDeviceImageInfoQCOM_ovr_6(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetDeviceImageInfoQCOM_ovr_8(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceImageInfoQCOM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceImageInfoQCOM(device: cl_device_id; image_width: UIntPtr; image_height: UIntPtr; image_format: IntPtr; param_name: ImagePitchInfoQcom; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetDeviceImageInfoQCOM_ovr_8(device, image_width, image_height, image_format, param_name, param_value_size, param_value, param_value_size_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clUseGrallocPtrIMG = static class
    public const _ExtStr = 'img_use_gralloc_ptr';
    
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGrallocObjectsIMG_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGrallocObjectsIMG_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGrallocObjectsIMG_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGrallocObjectsIMG_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGrallocObjectsIMG_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGrallocObjectsIMG_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGrallocObjectsIMG_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGrallocObjectsIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGrallocObjectsIMG(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGrallocObjectsIMG_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSubgroupsKHR = static class
    public const _ExtStr = 'khr_subgroups';
    
    private static function z_GetKernelSubGroupInfoKHR_ovr_0(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfoKHR';
    private static function z_GetKernelSubGroupInfoKHR_ovr_0_anh000000001(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfoKHR(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetKernelSubGroupInfoKHR_ovr_0(in_kernel, in_device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetKernelSubGroupInfoKHR_ovr_0_anh000000001(in_kernel, in_device, param_name, input_value_size, input_value, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfoKHR(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetKernelSubGroupInfoKHR_ovr_0(in_kernel, in_device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    private static function z_GetKernelSubGroupInfoKHR_ovr_2(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSubGroupInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSubGroupInfoKHR(in_kernel: cl_kernel; in_device: cl_device_id; param_name: KernelSubGroupInfo; input_value_size: UIntPtr; input_value: IntPtr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetKernelSubGroupInfoKHR_ovr_2(in_kernel, in_device, param_name, input_value_size, input_value, param_value_size, param_value, param_value_size_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clImportMemoryARM = static class
    public const _ExtStr = 'arm_import_memory';
    
    private static function z_ImportMemoryARM_ovr_0(context: cl_context; flags: MemFlags; var properties: ImportPropertiesArm; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clImportMemoryARM';
    private static function z_ImportMemoryARM_ovr_0_anh0001000(context: cl_context; flags: MemFlags; properties: IntPtr; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clImportMemoryARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ImportMemoryARM(context: cl_context; flags: MemFlags; properties: array of ImportPropertiesArm; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_ImportMemoryARM_ovr_0(context, flags, properties[0], memory, size, errcode_ret) else
      z_ImportMemoryARM_ovr_0_anh0001000(context, flags, IntPtr.Zero, memory, size, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ImportMemoryARM(context: cl_context; flags: MemFlags; var properties: ImportPropertiesArm; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_ImportMemoryARM_ovr_0(context, flags, properties, memory, size, errcode_ret);
    private static function z_ImportMemoryARM_ovr_2(context: cl_context; flags: MemFlags; properties: IntPtr; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clImportMemoryARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ImportMemoryARM(context: cl_context; flags: MemFlags; properties: IntPtr; memory: IntPtr; size: UIntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_ImportMemoryARM_ovr_2(context, flags, properties, memory, size, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharedVirtualMemoryARM = static class
    public const _ExtStr = 'arm_shared_virtual_memory';
    
    private static function z_SVMAllocARM_ovr_0(context: cl_context; flags: SvmMemFlagsArm; size: UIntPtr; alignment: UInt32): IntPtr;
    external 'opencl' name 'clSVMAllocARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SVMAllocARM(context: cl_context; flags: SvmMemFlagsArm; size: UIntPtr; alignment: UInt32): IntPtr :=
    z_SVMAllocARM_ovr_0(context, flags, size, alignment);
    
    private static procedure z_SVMFreeARM_ovr_0(context: cl_context; svm_pointer: IntPtr);
    external 'opencl' name 'clSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure SVMFreeARM(context: cl_context; svm_pointer: IntPtr) :=
    z_SVMFreeARM_ovr_0(context, svm_pointer);
    
    private static function z_EnqueueSVMFreeARM_ovr_0(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_0_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_0_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_0_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFreeARM_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFreeARM_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFreeARM_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFreeARM_ovr_0_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFreeARM_ovr_1(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_1_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_1_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_1_anh000100010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFreeARM_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFreeARM_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSVMFreeARM_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSVMFreeARM_ovr_1_anh000100010(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFreeARM_ovr_2_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_0(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFreeARM_ovr_0_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_3_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_1(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFreeARM_ovr_1_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_4(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_4_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_4(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFreeARM_ovr_4_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_5(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_5_anh000100000(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: array of IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (svm_pointers<>nil) and (svm_pointers.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_5(command_queue, num_svm_pointers, svm_pointers[0], pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSVMFreeARM_ovr_5_anh000100000(command_queue, num_svm_pointers, IntPtr.Zero, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_0(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFreeARM_ovr_0_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_1(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFreeARM_ovr_1_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_0(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_1(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_4(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; var svm_pointers: IntPtr; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_5(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_12(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_12_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_12(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFreeARM_ovr_12_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMFreeARM_ovr_13(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    private static function z_EnqueueSVMFreeARM_ovr_13_anh000000010(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMFreeARM_ovr_13(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMFreeARM_ovr_13_anh000000010(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_12(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_13(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_16(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_16(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMFreeARM_ovr_17(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMFreeARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMFreeARM(command_queue: cl_command_queue; num_svm_pointers: UInt32; svm_pointers: pointer; pfn_free_func: EnqueueSVMFreeCallback; user_data: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMFreeARM_ovr_17(command_queue, num_svm_pointers, svm_pointers, pfn_free_func, user_data, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueSVMMemcpyARM_ovr_0(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    private static function z_EnqueueSVMMemcpyARM_ovr_0_anh000000010(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemcpyARM_ovr_0(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemcpyARM_ovr_0_anh000000010(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMemcpyARM_ovr_1(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    private static function z_EnqueueSVMMemcpyARM_ovr_1_anh000000010(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemcpyARM_ovr_1(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemcpyARM_ovr_1_anh000000010(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemcpyARM_ovr_0(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemcpyARM_ovr_1(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemcpyARM_ovr_4(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemcpyARM_ovr_4(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemcpyARM_ovr_5(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemcpyARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemcpyARM(command_queue: cl_command_queue; blocking_copy: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemcpyARM_ovr_5(command_queue, blocking_copy, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueSVMMemFillARM_ovr_0(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    private static function z_EnqueueSVMMemFillARM_ovr_0_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFillARM_ovr_0(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFillARM_ovr_0_anh000000010(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMemFillARM_ovr_1(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    private static function z_EnqueueSVMMemFillARM_ovr_1_anh000000010(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMemFillARM_ovr_1(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMemFillARM_ovr_1_anh000000010(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFillARM_ovr_0(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFillARM_ovr_1(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemFillARM_ovr_4(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMemFillARM_ovr_4(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMemFillARM_ovr_5(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMemFillARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMemFillARM(command_queue: cl_command_queue; svm_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMemFillARM_ovr_5(command_queue, svm_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueSVMMapARM_ovr_0(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    private static function z_EnqueueSVMMapARM_ovr_0_anh000000010(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMapARM_ovr_0(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMapARM_ovr_0_anh000000010(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMMapARM_ovr_1(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    private static function z_EnqueueSVMMapARM_ovr_1_anh000000010(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMMapARM_ovr_1(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMMapARM_ovr_1_anh000000010(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMapARM_ovr_0(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMapARM_ovr_1(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMapARM_ovr_4(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMMapARM_ovr_4(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMMapARM_ovr_5(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMMapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMMapARM(command_queue: cl_command_queue; blocking_map: Bool; flags: MapFlags; svm_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMMapARM_ovr_5(command_queue, blocking_map, flags, svm_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueSVMUnmapARM_ovr_0(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    private static function z_EnqueueSVMUnmapARM_ovr_0_anh000010(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMUnmapARM_ovr_0(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMUnmapARM_ovr_0_anh000010(command_queue, svm_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSVMUnmapARM_ovr_1(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    private static function z_EnqueueSVMUnmapARM_ovr_1_anh000010(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSVMUnmapARM_ovr_1(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSVMUnmapARM_ovr_1_anh000010(command_queue, svm_ptr, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMUnmapARM_ovr_0(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMUnmapARM_ovr_1(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMUnmapARM_ovr_4(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSVMUnmapARM_ovr_4(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSVMUnmapARM_ovr_5(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSVMUnmapARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSVMUnmapARM(command_queue: cl_command_queue; svm_ptr: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSVMUnmapARM_ovr_5(command_queue, svm_ptr, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_SetKernelArgSVMPointerARM_ovr_0(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetKernelArgSVMPointerARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelArgSVMPointerARM(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode :=
    z_SetKernelArgSVMPointerARM_ovr_0(kernel, arg_index, arg_value);
    
    private static function z_SetKernelExecInfoARM_ovr_0(kernel: cl_kernel; param_name: KernelExecInfoArm; param_value_size: UIntPtr; param_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetKernelExecInfoARM';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelExecInfoARM(kernel: cl_kernel; param_name: KernelExecInfoArm; param_value_size: UIntPtr; param_value: IntPtr): ErrorCode :=
    z_SetKernelExecInfoARM_ovr_0(kernel, param_name, param_value_size, param_value);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clAcceleratorINTEL = static class
    public const _ExtStr = 'intel_accelerator';
    
    private static function z_CreateAcceleratorINTEL_ovr_0(context: cl_context; accelerator_type: AcceleratorTypeIntel; descriptor_size: UIntPtr; descriptor: IntPtr; var errcode_ret: ErrorCode): cl_accelerator_intel;
    external 'opencl' name 'clCreateAcceleratorINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAcceleratorINTEL(context: cl_context; accelerator_type: AcceleratorTypeIntel; descriptor_size: UIntPtr; descriptor: IntPtr; var errcode_ret: ErrorCode): cl_accelerator_intel :=
    z_CreateAcceleratorINTEL_ovr_0(context, accelerator_type, descriptor_size, descriptor, errcode_ret);
    
    private static function z_GetAcceleratorInfoINTEL_ovr_0(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetAcceleratorInfoINTEL';
    private static function z_GetAcceleratorInfoINTEL_ovr_0_anh000001(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetAcceleratorInfoINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetAcceleratorInfoINTEL(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetAcceleratorInfoINTEL_ovr_0(accelerator, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetAcceleratorInfoINTEL_ovr_0_anh000001(accelerator, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetAcceleratorInfoINTEL(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetAcceleratorInfoINTEL_ovr_0(accelerator, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetAcceleratorInfoINTEL_ovr_2(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetAcceleratorInfoINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetAcceleratorInfoINTEL(accelerator: cl_accelerator_intel; param_name: AcceleratorInfoIntel; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetAcceleratorInfoINTEL_ovr_2(accelerator, param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_RetainAcceleratorINTEL_ovr_0(accelerator: cl_accelerator_intel): ErrorCode;
    external 'opencl' name 'clRetainAcceleratorINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainAcceleratorINTEL(accelerator: cl_accelerator_intel): ErrorCode :=
    z_RetainAcceleratorINTEL_ovr_0(accelerator);
    
    private static function z_ReleaseAcceleratorINTEL_ovr_0(accelerator: cl_accelerator_intel): ErrorCode;
    external 'opencl' name 'clReleaseAcceleratorINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseAcceleratorINTEL(accelerator: cl_accelerator_intel): ErrorCode :=
    z_ReleaseAcceleratorINTEL_ovr_0(accelerator);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clGlEventKHR = static class
    public const _ExtStr = 'khr_gl_event';
    
    private static function z_CreateEventFromGLsyncKHR_ovr_0(context: cl_context; sync: IntPtr; var errcode_ret: ErrorCode): cl_event;
    external 'opencl' name 'clCreateEventFromGLsyncKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateEventFromGLsyncKHR(context: cl_context; sync: IntPtr; var errcode_ret: ErrorCode): cl_event :=
    z_CreateEventFromGLsyncKHR_ovr_0(context, sync, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clVaApiMediaSharingINTEL = static class
    public const _ExtStr = 'intel_va_api_media_sharing';
    
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000010(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000001(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000011(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000001(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000010(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000011(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_1_anh00000010(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000010(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_2(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_2_anh00000010(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_2(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_2_anh00000010(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0_anh00000001(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_0(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_2(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_6(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_6_anh00000001(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_6(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_6_anh00000001(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_6(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_8(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromVA_APIMediaAdapterINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromVA_APIMediaAdapterINTEL(platform: cl_platform_id; media_adapter_type: VaApiDeviceSourceIntel; media_adapter: IntPtr; media_adapter_set: VaApiDeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromVA_APIMediaAdapterINTEL_ovr_8(platform, media_adapter_type, media_adapter, media_adapter_set, num_entries, devices, num_devices);
    
    private static function z_CreateFromVA_APIMediaSurfaceINTEL_ovr_0(context: cl_context; flags: MemFlags; var surface: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromVA_APIMediaSurfaceINTEL';
    private static function z_CreateFromVA_APIMediaSurfaceINTEL_ovr_0_anh000100(context: cl_context; flags: MemFlags; surface: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromVA_APIMediaSurfaceINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromVA_APIMediaSurfaceINTEL(context: cl_context; flags: MemFlags; surface: array of IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (surface<>nil) and (surface.Length<>0) then
      z_CreateFromVA_APIMediaSurfaceINTEL_ovr_0(context, flags, surface[0], plane, errcode_ret) else
      z_CreateFromVA_APIMediaSurfaceINTEL_ovr_0_anh000100(context, flags, IntPtr.Zero, plane, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromVA_APIMediaSurfaceINTEL(context: cl_context; flags: MemFlags; var surface: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromVA_APIMediaSurfaceINTEL_ovr_0(context, flags, surface, plane, errcode_ret);
    private static function z_CreateFromVA_APIMediaSurfaceINTEL_ovr_2(context: cl_context; flags: MemFlags; surface: pointer; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromVA_APIMediaSurfaceINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromVA_APIMediaSurfaceINTEL(context: cl_context; flags: MemFlags; surface: pointer; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromVA_APIMediaSurfaceINTEL_ovr_2(context, flags, surface, plane, errcode_ret);
    
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireVA_APIMediaSurfacesINTEL_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseVA_APIMediaSurfacesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseVA_APIMediaSurfacesINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseVA_APIMediaSurfacesINTEL_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clDx9MediaSharingINTEL = static class
    public const _ExtStr = 'intel_dx9_media_sharing';
    
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_0(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000010(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000001(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000011(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9INTEL_ovr_0(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices[0], num_devices[0]) else
        z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000001(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices[0], IntPtr.Zero) else
      if (num_devices<>nil) and (num_devices.Length<>0) then
        z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000010(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, IntPtr.Zero, num_devices[0]) else
        z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000011(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_1_anh00000010(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; var num_devices: UInt32): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9INTEL_ovr_0(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000010(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, IntPtr.Zero, num_devices);
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_2(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_2_anh00000010(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: array of cl_device_id; num_devices: IntPtr): ErrorCode :=
    if (devices<>nil) and (devices.Length<>0) then
      z_GetDeviceIDsFromDX9INTEL_ovr_2(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices[0], num_devices) else
      z_GetDeviceIDsFromDX9INTEL_ovr_2_anh00000010(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, IntPtr.Zero, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9INTEL_ovr_0(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9INTEL_ovr_0_anh00000001(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9INTEL_ovr_0(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; var devices: cl_device_id; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9INTEL_ovr_2(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_6(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_6_anh00000001(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: array of UInt32): ErrorCode :=
    if (num_devices<>nil) and (num_devices.Length<>0) then
      z_GetDeviceIDsFromDX9INTEL_ovr_6(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices[0]) else
      z_GetDeviceIDsFromDX9INTEL_ovr_6_anh00000001(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; var num_devices: UInt32): ErrorCode :=
    z_GetDeviceIDsFromDX9INTEL_ovr_6(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices);
    private static function z_GetDeviceIDsFromDX9INTEL_ovr_8(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode;
    external 'opencl' name 'clGetDeviceIDsFromDX9INTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDeviceIDsFromDX9INTEL(platform: cl_platform_id; dx9_device_source: Dx9DeviceSourceIntel; dx9_object: IntPtr; dx9_device_set: Dx9DeviceSetIntel; num_entries: UInt32; devices: IntPtr; num_devices: IntPtr): ErrorCode :=
    z_GetDeviceIDsFromDX9INTEL_ovr_8(platform, dx9_device_source, dx9_object, dx9_device_set, num_entries, devices, num_devices);
    
    private static function z_CreateFromDX9MediaSurfaceINTEL_ovr_0(context: cl_context; flags: MemFlags; var resource: IntPtr; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromDX9MediaSurfaceINTEL';
    private static function z_CreateFromDX9MediaSurfaceINTEL_ovr_0_anh0001000(context: cl_context; flags: MemFlags; resource: IntPtr; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromDX9MediaSurfaceINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromDX9MediaSurfaceINTEL(context: cl_context; flags: MemFlags; resource: array of IntPtr; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    if (resource<>nil) and (resource.Length<>0) then
      z_CreateFromDX9MediaSurfaceINTEL_ovr_0(context, flags, resource[0], sharedHandle, plane, errcode_ret) else
      z_CreateFromDX9MediaSurfaceINTEL_ovr_0_anh0001000(context, flags, IntPtr.Zero, sharedHandle, plane, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromDX9MediaSurfaceINTEL(context: cl_context; flags: MemFlags; var resource: IntPtr; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromDX9MediaSurfaceINTEL_ovr_0(context, flags, resource, sharedHandle, plane, errcode_ret);
    private static function z_CreateFromDX9MediaSurfaceINTEL_ovr_2(context: cl_context; flags: MemFlags; resource: pointer; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromDX9MediaSurfaceINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromDX9MediaSurfaceINTEL(context: cl_context; flags: MemFlags; resource: pointer; sharedHandle: IntPtr; plane: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromDX9MediaSurfaceINTEL_ovr_2(context, flags, resource, sharedHandle, plane, errcode_ret);
    
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireDX9ObjectsINTEL_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireDX9ObjectsINTEL_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireDX9ObjectsINTEL_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseDX9ObjectsINTEL_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseDX9ObjectsINTEL_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseDX9ObjectsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseDX9ObjectsINTEL(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseDX9ObjectsINTEL_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clGlSharingKHR = static class
    public const _ExtStr = 'khr_gl_sharing';
    
    private static function z_GetGLContextInfoKHR_ovr_0(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    private static function z_GetGLContextInfoKHR_ovr_0_anh010000(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    private static function z_GetGLContextInfoKHR_ovr_0_anh000001(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    private static function z_GetGLContextInfoKHR_ovr_0_anh010001(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: array of ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
        z_GetGLContextInfoKHR_ovr_0(properties[0], param_name, param_value_size, param_value, param_value_size_ret[0]) else
        z_GetGLContextInfoKHR_ovr_0_anh000001(properties[0], param_name, param_value_size, param_value, IntPtr.Zero) else
      if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
        z_GetGLContextInfoKHR_ovr_0_anh010000(IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret[0]) else
        z_GetGLContextInfoKHR_ovr_0_anh010001(IntPtr.Zero, param_name, param_value_size, param_value, IntPtr.Zero);
    private static function z_GetGLContextInfoKHR_ovr_1_anh010000(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: array of ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_GetGLContextInfoKHR_ovr_0(properties[0], param_name, param_value_size, param_value, param_value_size_ret) else
      z_GetGLContextInfoKHR_ovr_0_anh010000(IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetGLContextInfoKHR_ovr_2(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    private static function z_GetGLContextInfoKHR_ovr_2_anh010000(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: array of ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    if (properties<>nil) and (properties.Length<>0) then
      z_GetGLContextInfoKHR_ovr_2(properties[0], param_name, param_value_size, param_value, param_value_size_ret) else
      z_GetGLContextInfoKHR_ovr_2_anh010000(IntPtr.Zero, param_name, param_value_size, param_value, param_value_size_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetGLContextInfoKHR_ovr_0(properties, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetGLContextInfoKHR_ovr_0_anh000001(properties, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetGLContextInfoKHR_ovr_0(properties, param_name, param_value_size, param_value, param_value_size_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(var properties: ContextProperties; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetGLContextInfoKHR_ovr_2(properties, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetGLContextInfoKHR_ovr_6(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    private static function z_GetGLContextInfoKHR_ovr_6_anh000001(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetGLContextInfoKHR_ovr_6(properties, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetGLContextInfoKHR_ovr_6_anh000001(properties, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetGLContextInfoKHR_ovr_6(properties, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetGLContextInfoKHR_ovr_8(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLContextInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLContextInfoKHR(properties: IntPtr; param_name: GlContextInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetGLContextInfoKHR_ovr_8(properties, param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_CreateFromGLBuffer_ovr_0(context: cl_context; flags: MemFlags; bufobj: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromGLBuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromGLBuffer(context: cl_context; flags: MemFlags; bufobj: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromGLBuffer_ovr_0(context, flags, bufobj, errcode_ret);
    
    private static function z_CreateFromGLTexture_ovr_0(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromGLTexture';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromGLTexture(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromGLTexture_ovr_0(context, flags, target, miplevel, texture, errcode_ret);
    
    private static function z_CreateFromGLRenderbuffer_ovr_0(context: cl_context; flags: MemFlags; renderbuffer: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromGLRenderbuffer';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromGLRenderbuffer(context: cl_context; flags: MemFlags; renderbuffer: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromGLRenderbuffer_ovr_0(context, flags, renderbuffer, errcode_ret);
    
    private static function z_GetGLObjectInfo_ovr_0(memobj: cl_mem; var gl_object_type: GlObjectType; var gl_object_name: UInt32): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    private static function z_GetGLObjectInfo_ovr_0_anh0010(memobj: cl_mem; gl_object_type: IntPtr; var gl_object_name: UInt32): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    private static function z_GetGLObjectInfo_ovr_0_anh0001(memobj: cl_mem; var gl_object_type: GlObjectType; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    private static function z_GetGLObjectInfo_ovr_0_anh0011(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: array of GlObjectType; gl_object_name: array of UInt32): ErrorCode :=
    if (gl_object_type<>nil) and (gl_object_type.Length<>0) then
      if (gl_object_name<>nil) and (gl_object_name.Length<>0) then
        z_GetGLObjectInfo_ovr_0(memobj, gl_object_type[0], gl_object_name[0]) else
        z_GetGLObjectInfo_ovr_0_anh0001(memobj, gl_object_type[0], IntPtr.Zero) else
      if (gl_object_name<>nil) and (gl_object_name.Length<>0) then
        z_GetGLObjectInfo_ovr_0_anh0010(memobj, IntPtr.Zero, gl_object_name[0]) else
        z_GetGLObjectInfo_ovr_0_anh0011(memobj, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetGLObjectInfo_ovr_1_anh0010(memobj: cl_mem; gl_object_type: IntPtr; var gl_object_name: UInt32): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: array of GlObjectType; var gl_object_name: UInt32): ErrorCode :=
    if (gl_object_type<>nil) and (gl_object_type.Length<>0) then
      z_GetGLObjectInfo_ovr_0(memobj, gl_object_type[0], gl_object_name) else
      z_GetGLObjectInfo_ovr_0_anh0010(memobj, IntPtr.Zero, gl_object_name);
    private static function z_GetGLObjectInfo_ovr_2(memobj: cl_mem; var gl_object_type: GlObjectType; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    private static function z_GetGLObjectInfo_ovr_2_anh0010(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: array of GlObjectType; gl_object_name: IntPtr): ErrorCode :=
    if (gl_object_type<>nil) and (gl_object_type.Length<>0) then
      z_GetGLObjectInfo_ovr_2(memobj, gl_object_type[0], gl_object_name) else
      z_GetGLObjectInfo_ovr_2_anh0010(memobj, IntPtr.Zero, gl_object_name);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; var gl_object_type: GlObjectType; gl_object_name: array of UInt32): ErrorCode :=
    if (gl_object_name<>nil) and (gl_object_name.Length<>0) then
      z_GetGLObjectInfo_ovr_0(memobj, gl_object_type, gl_object_name[0]) else
      z_GetGLObjectInfo_ovr_0_anh0001(memobj, gl_object_type, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; var gl_object_type: GlObjectType; var gl_object_name: UInt32): ErrorCode :=
    z_GetGLObjectInfo_ovr_0(memobj, gl_object_type, gl_object_name);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; var gl_object_type: GlObjectType; gl_object_name: IntPtr): ErrorCode :=
    z_GetGLObjectInfo_ovr_2(memobj, gl_object_type, gl_object_name);
    private static function z_GetGLObjectInfo_ovr_6(memobj: cl_mem; gl_object_type: IntPtr; var gl_object_name: UInt32): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    private static function z_GetGLObjectInfo_ovr_6_anh0001(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: array of UInt32): ErrorCode :=
    if (gl_object_name<>nil) and (gl_object_name.Length<>0) then
      z_GetGLObjectInfo_ovr_6(memobj, gl_object_type, gl_object_name[0]) else
      z_GetGLObjectInfo_ovr_6_anh0001(memobj, gl_object_type, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: IntPtr; var gl_object_name: UInt32): ErrorCode :=
    z_GetGLObjectInfo_ovr_6(memobj, gl_object_type, gl_object_name);
    private static function z_GetGLObjectInfo_ovr_8(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLObjectInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLObjectInfo(memobj: cl_mem; gl_object_type: IntPtr; gl_object_name: IntPtr): ErrorCode :=
    z_GetGLObjectInfo_ovr_8(memobj, gl_object_type, gl_object_name);
    
    private static function z_GetGLTextureInfo_ovr_0(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetGLTextureInfo';
    private static function z_GetGLTextureInfo_ovr_0_anh000001(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLTextureInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLTextureInfo(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetGLTextureInfo_ovr_0(memobj, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetGLTextureInfo_ovr_0_anh000001(memobj, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLTextureInfo(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetGLTextureInfo_ovr_0(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetGLTextureInfo_ovr_2(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetGLTextureInfo';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGLTextureInfo(memobj: cl_mem; param_name: GlTextureInfo; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetGLTextureInfo_ovr_2(memobj, param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_EnqueueAcquireGLObjects_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGLObjects_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGLObjects_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGLObjects_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGLObjects_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGLObjects_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGLObjects_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireGLObjects_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireGLObjects_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGLObjects_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGLObjects_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGLObjects_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireGLObjects_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGLObjects_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGLObjects_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGLObjects_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    private static function z_EnqueueAcquireGLObjects_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireGLObjects_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireGLObjects_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireGLObjects_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireGLObjects_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseGLObjects_ovr_0(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_0_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_0_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_0_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGLObjects_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGLObjects_ovr_0_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGLObjects_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGLObjects_ovr_0_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_1(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_1_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_1_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_1_anh0001010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGLObjects_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGLObjects_ovr_1_anh0000010(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseGLObjects_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseGLObjects_ovr_1_anh0001010(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_2_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_0(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGLObjects_ovr_0_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_3_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_1(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGLObjects_ovr_1_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_4(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_4_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_4(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGLObjects_ovr_4_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_5(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_5_anh0001000(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_5(command_queue, num_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseGLObjects_ovr_5_anh0001000(command_queue, num_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGLObjects_ovr_0_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGLObjects_ovr_1_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_0(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_1(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_4(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_5(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_12(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_12_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGLObjects_ovr_12_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_13(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    private static function z_EnqueueReleaseGLObjects_ovr_13_anh0000010(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseGLObjects_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseGLObjects_ovr_13_anh0000010(command_queue, num_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_12(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_13(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_16(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_16(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseGLObjects_ovr_17(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseGLObjects';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseGLObjects(command_queue: cl_command_queue; num_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseGLObjects_ovr_17(command_queue, num_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_CreateFromGLTexture2D_ovr_0(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromGLTexture2D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromGLTexture2D(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromGLTexture2D_ovr_0(context, flags, target, miplevel, texture, errcode_ret);
    
    private static function z_CreateFromGLTexture3D_ovr_0(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateFromGLTexture3D';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateFromGLTexture3D(context: cl_context; flags: MemFlags; target: UInt32; miplevel: Int32; texture: UInt32; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateFromGLTexture3D_ovr_0(context, flags, target, miplevel, texture, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clUnifiedSharedMemoryINTEL = static class
    public const _ExtStr = 'intel_unified_shared_memory';
    
    private static function z_HostMemAllocINTEL_ovr_0(context: cl_context; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clHostMemAllocINTEL';
    private static function z_HostMemAllocINTEL_ovr_0_anh001000(context: cl_context; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clHostMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function HostMemAllocINTEL(context: cl_context; properties: array of MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    if (properties<>nil) and (properties.Length<>0) then
      z_HostMemAllocINTEL_ovr_0(context, properties[0], size, alignment, errcode_ret) else
      z_HostMemAllocINTEL_ovr_0_anh001000(context, IntPtr.Zero, size, alignment, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function HostMemAllocINTEL(context: cl_context; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_HostMemAllocINTEL_ovr_0(context, properties, size, alignment, errcode_ret);
    private static function z_HostMemAllocINTEL_ovr_2(context: cl_context; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clHostMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function HostMemAllocINTEL(context: cl_context; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_HostMemAllocINTEL_ovr_2(context, properties, size, alignment, errcode_ret);
    
    private static function z_DeviceMemAllocINTEL_ovr_0(context: cl_context; device: cl_device_id; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clDeviceMemAllocINTEL';
    private static function z_DeviceMemAllocINTEL_ovr_0_anh0001000(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clDeviceMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeviceMemAllocINTEL(context: cl_context; device: cl_device_id; properties: array of MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    if (properties<>nil) and (properties.Length<>0) then
      z_DeviceMemAllocINTEL_ovr_0(context, device, properties[0], size, alignment, errcode_ret) else
      z_DeviceMemAllocINTEL_ovr_0_anh0001000(context, device, IntPtr.Zero, size, alignment, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeviceMemAllocINTEL(context: cl_context; device: cl_device_id; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_DeviceMemAllocINTEL_ovr_0(context, device, properties, size, alignment, errcode_ret);
    private static function z_DeviceMemAllocINTEL_ovr_2(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clDeviceMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeviceMemAllocINTEL(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_DeviceMemAllocINTEL_ovr_2(context, device, properties, size, alignment, errcode_ret);
    
    private static function z_SharedMemAllocINTEL_ovr_0(context: cl_context; device: cl_device_id; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clSharedMemAllocINTEL';
    private static function z_SharedMemAllocINTEL_ovr_0_anh0001000(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clSharedMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SharedMemAllocINTEL(context: cl_context; device: cl_device_id; properties: array of MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    if (properties<>nil) and (properties.Length<>0) then
      z_SharedMemAllocINTEL_ovr_0(context, device, properties[0], size, alignment, errcode_ret) else
      z_SharedMemAllocINTEL_ovr_0_anh0001000(context, device, IntPtr.Zero, size, alignment, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SharedMemAllocINTEL(context: cl_context; device: cl_device_id; var properties: MemPropertiesIntel; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_SharedMemAllocINTEL_ovr_0(context, device, properties, size, alignment, errcode_ret);
    private static function z_SharedMemAllocINTEL_ovr_2(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr;
    external 'opencl' name 'clSharedMemAllocINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SharedMemAllocINTEL(context: cl_context; device: cl_device_id; properties: IntPtr; size: UIntPtr; alignment: UInt32; var errcode_ret: ErrorCode): IntPtr :=
    z_SharedMemAllocINTEL_ovr_2(context, device, properties, size, alignment, errcode_ret);
    
    private static function z_MemFreeINTEL_ovr_0(context: cl_context; ptr: IntPtr): ErrorCode;
    external 'opencl' name 'clMemFreeINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MemFreeINTEL(context: cl_context; ptr: IntPtr): ErrorCode :=
    z_MemFreeINTEL_ovr_0(context, ptr);
    
    private static function z_MemBlockingFreeINTEL_ovr_0(context: cl_context; ptr: IntPtr): ErrorCode;
    external 'opencl' name 'clMemBlockingFreeINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MemBlockingFreeINTEL(context: cl_context; ptr: IntPtr): ErrorCode :=
    z_MemBlockingFreeINTEL_ovr_0(context, ptr);
    
    private static function z_GetMemAllocInfoINTEL_ovr_0(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetMemAllocInfoINTEL';
    private static function z_GetMemAllocInfoINTEL_ovr_0_anh0000001(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemAllocInfoINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemAllocInfoINTEL(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetMemAllocInfoINTEL_ovr_0(context, ptr, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetMemAllocInfoINTEL_ovr_0_anh0000001(context, ptr, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemAllocInfoINTEL(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetMemAllocInfoINTEL_ovr_0(context, ptr, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetMemAllocInfoINTEL_ovr_2(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetMemAllocInfoINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMemAllocInfoINTEL(context: cl_context; ptr: IntPtr; param_name: UInt32; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetMemAllocInfoINTEL_ovr_2(context, ptr, param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_SetKernelArgMemPointerINTEL_ovr_0(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode;
    external 'opencl' name 'clSetKernelArgMemPointerINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetKernelArgMemPointerINTEL(kernel: cl_kernel; arg_index: UInt32; arg_value: IntPtr): ErrorCode :=
    z_SetKernelArgMemPointerINTEL_ovr_0(kernel, arg_index, arg_value);
    
    private static function z_EnqueueMemFillINTEL_ovr_0(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    private static function z_EnqueueMemFillINTEL_ovr_0_anh000000010(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemFillINTEL_ovr_0(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemFillINTEL_ovr_0_anh000000010(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMemFillINTEL_ovr_1(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    private static function z_EnqueueMemFillINTEL_ovr_1_anh000000010(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemFillINTEL_ovr_1(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemFillINTEL_ovr_1_anh000000010(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMemFillINTEL_ovr_0(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMemFillINTEL_ovr_1(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemFillINTEL_ovr_4(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMemFillINTEL_ovr_4(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemFillINTEL_ovr_5(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemFillINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemFillINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; pattern: IntPtr; pattern_size: UIntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMemFillINTEL_ovr_5(command_queue, dst_ptr, pattern, pattern_size, size, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueMemcpyINTEL_ovr_0(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    private static function z_EnqueueMemcpyINTEL_ovr_0_anh000000010(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemcpyINTEL_ovr_0(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemcpyINTEL_ovr_0_anh000000010(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMemcpyINTEL_ovr_1(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    private static function z_EnqueueMemcpyINTEL_ovr_1_anh000000010(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemcpyINTEL_ovr_1(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemcpyINTEL_ovr_1_anh000000010(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMemcpyINTEL_ovr_0(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMemcpyINTEL_ovr_1(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemcpyINTEL_ovr_4(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMemcpyINTEL_ovr_4(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemcpyINTEL_ovr_5(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemcpyINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemcpyINTEL(command_queue: cl_command_queue; blocking: Bool; dst_ptr: IntPtr; src_ptr: IntPtr; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMemcpyINTEL_ovr_5(command_queue, blocking, dst_ptr, src_ptr, size, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueMemAdviseINTEL_ovr_0(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    private static function z_EnqueueMemAdviseINTEL_ovr_0_anh00000010(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemAdviseINTEL_ovr_0(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemAdviseINTEL_ovr_0_anh00000010(command_queue, ptr, size, advice, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMemAdviseINTEL_ovr_1(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    private static function z_EnqueueMemAdviseINTEL_ovr_1_anh00000010(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemAdviseINTEL_ovr_1(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemAdviseINTEL_ovr_1_anh00000010(command_queue, ptr, size, advice, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMemAdviseINTEL_ovr_0(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMemAdviseINTEL_ovr_1(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemAdviseINTEL_ovr_4(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMemAdviseINTEL_ovr_4(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemAdviseINTEL_ovr_5(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemAdviseINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemAdviseINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; advice: UInt32; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMemAdviseINTEL_ovr_5(command_queue, ptr, size, advice, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueMigrateMemINTEL_ovr_0(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    private static function z_EnqueueMigrateMemINTEL_ovr_0_anh00000010(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemINTEL_ovr_0(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemINTEL_ovr_0_anh00000010(command_queue, ptr, size, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMigrateMemINTEL_ovr_1(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    private static function z_EnqueueMigrateMemINTEL_ovr_1_anh00000010(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMigrateMemINTEL_ovr_1(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMigrateMemINTEL_ovr_1_anh00000010(command_queue, ptr, size, flags, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemINTEL_ovr_0(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemINTEL_ovr_1(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemINTEL_ovr_4(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMigrateMemINTEL_ovr_4(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMigrateMemINTEL_ovr_5(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMigrateMemINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMigrateMemINTEL(command_queue: cl_command_queue; ptr: IntPtr; size: UIntPtr; flags: MemMigrationFlags; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMigrateMemINTEL_ovr_5(command_queue, ptr, size, flags, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueMemsetINTEL_ovr_0(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    private static function z_EnqueueMemsetINTEL_ovr_0_anh00000010(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemsetINTEL_ovr_0(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemsetINTEL_ovr_0_anh00000010(command_queue, dst_ptr, value, size, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueMemsetINTEL_ovr_1(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    private static function z_EnqueueMemsetINTEL_ovr_1_anh00000010(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueMemsetINTEL_ovr_1(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueMemsetINTEL_ovr_1_anh00000010(command_queue, dst_ptr, value, size, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueMemsetINTEL_ovr_0(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueMemsetINTEL_ovr_1(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemsetINTEL_ovr_4(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueMemsetINTEL_ovr_4(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueMemsetINTEL_ovr_5(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueMemsetINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueMemsetINTEL(command_queue: cl_command_queue; dst_ptr: IntPtr; value: Int32; size: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueMemsetINTEL_ovr_5(command_queue, dst_ptr, value, size, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clCreateBufferWithPropertiesINTEL = static class
    public const _ExtStr = 'intel_create_buffer_with_properties';
    
    private static function z_CreateBufferWithPropertiesINTEL_ovr_0(context: cl_context; var properties: MemPropertiesIntel; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithPropertiesINTEL';
    private static function z_CreateBufferWithPropertiesINTEL_ovr_0_anh0010000(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithPropertiesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithPropertiesINTEL(context: cl_context; properties: array of MemPropertiesIntel; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateBufferWithPropertiesINTEL_ovr_0(context, properties[0], flags, size, host_ptr, errcode_ret) else
      z_CreateBufferWithPropertiesINTEL_ovr_0_anh0010000(context, IntPtr.Zero, flags, size, host_ptr, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithPropertiesINTEL(context: cl_context; var properties: MemPropertiesIntel; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBufferWithPropertiesINTEL_ovr_0(context, properties, flags, size, host_ptr, errcode_ret);
    private static function z_CreateBufferWithPropertiesINTEL_ovr_2(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem;
    external 'opencl' name 'clCreateBufferWithPropertiesINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferWithPropertiesINTEL(context: cl_context; properties: IntPtr; flags: MemFlags; size: UIntPtr; host_ptr: IntPtr; var errcode_ret: ErrorCode): cl_mem :=
    z_CreateBufferWithPropertiesINTEL_ovr_2(context, properties, flags, size, host_ptr, errcode_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clGenerateMipmapIMG = static class
    public const _ExtStr = 'img_generate_mipmap';
    
    private static function z_EnqueueGenerateMipmapIMG_ovr_0(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_0_anh0000011010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_0_anh0000011010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_1(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_1_anh0000011010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueGenerateMipmapIMG_ovr_1_anh0000011010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_2_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_2_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_2_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_3_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_3_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_3_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_4(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_4_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_4_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_4_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_4(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_4_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_4_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_4_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_5(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_5_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_5_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_5_anh0000011000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_5(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_5_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (mip_region<>nil) and (mip_region.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_5_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueGenerateMipmapIMG_ovr_5_anh0000011000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_6_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_6_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_7_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_7_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_8_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_0_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_9_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_1_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_10_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_4(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_4_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_11_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_5(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_5_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_12(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_12_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_12_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_12_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_12(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_12_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_12_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_12_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_13(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_13_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_13_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_13_anh0000010010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_13(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_13_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_13_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_13_anh0000010010(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_14_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_12(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_12_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_15_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_13(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_13_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_16(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_16_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_16(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_16_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_17(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_17_anh0000010000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: array of UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (array_region<>nil) and (array_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_17(command_queue, src_image, dst_image, mipmap_filter_mode, array_region[0], mip_region, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_17_anh0000010000(command_queue, src_image, dst_image, mipmap_filter_mode, IntPtr.Zero, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_0_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_1_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_4(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_4_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_5(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_5_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_0_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_1_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_0(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_1(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_4(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_5(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_12(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_12_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_13(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_13_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_12(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_13(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_16(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; var array_region: UIntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_17(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_36(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_36_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_36_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_36_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_36(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_36_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_36_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_36_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_37(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_37_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_37_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_37_anh0000001010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_37(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_37_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueGenerateMipmapIMG_ovr_37_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueGenerateMipmapIMG_ovr_37_anh0000001010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_38_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_36(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_36_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_39_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_37(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_37_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_40(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_40_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_40(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_40_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_41(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_41_anh0000001000(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: array of UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mip_region<>nil) and (mip_region.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_41(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueGenerateMipmapIMG_ovr_41_anh0000001000(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_36(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_36_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_37(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_37_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_36(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_37(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_40(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; var mip_region: UIntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_41(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_48(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_48_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_48(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_48_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_49(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    private static function z_EnqueueGenerateMipmapIMG_ovr_49_anh0000000010(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueGenerateMipmapIMG_ovr_49(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueGenerateMipmapIMG_ovr_49_anh0000000010(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_48(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_49(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_52(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_52(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueGenerateMipmapIMG_ovr_53(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueGenerateMipmapIMG';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueGenerateMipmapIMG(command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; mipmap_filter_mode: MipmapFilterModeImg; array_region: IntPtr; mip_region: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueGenerateMipmapIMG_ovr_53(command_queue, src_image, dst_image, mipmap_filter_mode, array_region, mip_region, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSuggestedLocalWorkSizeKHR = static class
    public const _ExtStr = 'khr_suggested_local_work_size';
    
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000110(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000001(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000101(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000011(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000111(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], suggested_local_work_size[0]) else
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000001(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], IntPtr.Zero) else
        if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, suggested_local_work_size[0]) else
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000011(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, IntPtr.Zero) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], suggested_local_work_size[0]) else
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000101(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], IntPtr.Zero) else
        if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000110(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, suggested_local_work_size[0]) else
          z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000111(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_1_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_1_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_1_anh0000110(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], suggested_local_work_size) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, suggested_local_work_size) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], suggested_local_work_size) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000110(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000110(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2(command_queue, kernel, work_dim, global_work_offset[0], global_work_size[0], suggested_local_work_size) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000010(command_queue, kernel, work_dim, global_work_offset[0], IntPtr.Zero, suggested_local_work_size) else
      if (global_work_size<>nil) and (global_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size[0], suggested_local_work_size) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000110(command_queue, kernel, work_dim, IntPtr.Zero, IntPtr.Zero, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_3_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_3_anh0000101(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000001(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, IntPtr.Zero) else
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000101(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, IntPtr.Zero);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_4_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_5_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000001(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000101(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: IntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000001(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, IntPtr.Zero) else
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000101(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, IntPtr.Zero);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_7_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_8(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_8_anh0000100(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: array of UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    if (global_work_offset<>nil) and (global_work_offset.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_8(command_queue, kernel, work_dim, global_work_offset[0], global_work_size, suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_8_anh0000100(command_queue, kernel, work_dim, IntPtr.Zero, global_work_size, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], IntPtr.Zero) else
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000011(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: array of UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size[0]) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_0(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_2(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size[0]) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_6(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_8(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000001(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000011(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], IntPtr.Zero) else
      if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size[0]) else
        z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000011(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_19_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: array of UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_20(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_20_anh0000010(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: array of UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    if (global_work_size<>nil) and (global_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_20(command_queue, kernel, work_dim, global_work_offset, global_work_size[0], suggested_local_work_size) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_20_anh0000010(command_queue, kernel, work_dim, global_work_offset, IntPtr.Zero, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size[0]) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_18(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; var global_work_size: UIntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_20(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_24(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_24_anh0000001(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: array of UIntPtr): ErrorCode :=
    if (suggested_local_work_size<>nil) and (suggested_local_work_size.Length<>0) then
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_24(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size[0]) else
      z_GetKernelSuggestedLocalWorkSizeKHR_ovr_24_anh0000001(command_queue, kernel, work_dim, global_work_offset, global_work_size, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; var suggested_local_work_size: UIntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_24(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    private static function z_GetKernelSuggestedLocalWorkSizeKHR_ovr_26(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode;
    external 'opencl' name 'clGetKernelSuggestedLocalWorkSizeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetKernelSuggestedLocalWorkSizeKHR(command_queue: cl_command_queue; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; suggested_local_work_size: IntPtr): ErrorCode :=
    z_GetKernelSuggestedLocalWorkSizeKHR_ovr_26(command_queue, kernel, work_dim, global_work_offset, global_work_size, suggested_local_work_size);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSemaphoreKHR = static class
    public const _ExtStr = 'khr_semaphore';
    
    private static function z_CreateSemaphoreWithPropertiesKHR_ovr_0(context: cl_context; var sema_props: SemaphorePropertiesKhr; var errcode_ret: ErrorCode): cl_semaphore;
    external 'opencl' name 'clCreateSemaphoreWithPropertiesKHR';
    private static function z_CreateSemaphoreWithPropertiesKHR_ovr_0_anh0010(context: cl_context; sema_props: IntPtr; var errcode_ret: ErrorCode): cl_semaphore;
    external 'opencl' name 'clCreateSemaphoreWithPropertiesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSemaphoreWithPropertiesKHR(context: cl_context; sema_props: array of SemaphorePropertiesKhr; var errcode_ret: ErrorCode): cl_semaphore :=
    if (sema_props<>nil) and (sema_props.Length<>0) then
      z_CreateSemaphoreWithPropertiesKHR_ovr_0(context, sema_props[0], errcode_ret) else
      z_CreateSemaphoreWithPropertiesKHR_ovr_0_anh0010(context, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSemaphoreWithPropertiesKHR(context: cl_context; var sema_props: SemaphorePropertiesKhr; var errcode_ret: ErrorCode): cl_semaphore :=
    z_CreateSemaphoreWithPropertiesKHR_ovr_0(context, sema_props, errcode_ret);
    private static function z_CreateSemaphoreWithPropertiesKHR_ovr_2(context: cl_context; sema_props: IntPtr; var errcode_ret: ErrorCode): cl_semaphore;
    external 'opencl' name 'clCreateSemaphoreWithPropertiesKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateSemaphoreWithPropertiesKHR(context: cl_context; sema_props: IntPtr; var errcode_ret: ErrorCode): cl_semaphore :=
    z_CreateSemaphoreWithPropertiesKHR_ovr_2(context, sema_props, errcode_ret);
    
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_0_anh00011010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001010(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_0_anh00011010(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_1_anh00011010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001010(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueWaitSemaphoresKHR_ovr_1_anh00011010(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_2_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_2_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_2_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_3_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_3_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_3_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_4(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_4_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_4_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_4_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_4_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_4_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_4_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_5(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_5_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_5_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_5_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_5_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_5_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_5_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_6_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_6_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_7_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_7_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_8_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_9_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_10_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_4_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_11_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_5_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_12(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_12_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_12_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_12_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_12_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_12_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_12_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_13(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_13_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_13_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_13_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_13_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_13_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_13_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_14_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_12_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_15_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_13_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_16(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_16_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_16(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_16_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_17(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_17_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_17(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_17_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_4_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_5_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_12_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_13_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_16(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_17(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_36(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_36_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_36_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_36_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_36_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_36_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_36_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_37(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_37_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_37_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_37_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_37_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueWaitSemaphoresKHR_ovr_37_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueWaitSemaphoresKHR_ovr_37_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_38_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_36_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_39_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_37_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_40(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_40_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_40(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_40_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_41(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_41_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_41(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_41_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_36_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_37_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_40(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_41(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_48(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_48_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_48(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_48_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_49(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    private static function z_EnqueueWaitSemaphoresKHR_ovr_49_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueWaitSemaphoresKHR_ovr_49(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueWaitSemaphoresKHR_ovr_49_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_48(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_49(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_52(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_52(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueWaitSemaphoresKHR_ovr_53(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueWaitSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueWaitSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueWaitSemaphoresKHR_ovr_53(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_0_anh00011010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001010(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_0_anh00011010(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_1_anh00011010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001010(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
        if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
          z_EnqueueSignalSemaphoresKHR_ovr_1_anh00011010(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_2_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_2_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_2_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_3_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_3_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_3_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_4(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_4_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_4_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_4_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_4_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_4_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_4_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_5(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_5_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_5_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_5_anh00011000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects[0], sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_5_anh00001000(command_queue, num_sema_objects, sema_objects[0], IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event) else
      if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_5_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_5_anh00011000(command_queue, num_sema_objects, IntPtr.Zero, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_6_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_6_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_7_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_7_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_8_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_0_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_9_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_1_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_10_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_4_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_11_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_5_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_12(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_12_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_12_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_12_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_12_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_12_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_12_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_13(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_13_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_13_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_13_anh00010010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_13_anh00000010(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_13_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_13_anh00010010(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_14_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_12_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_15_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_13_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_16(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_16_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_16(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_16_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_17(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_17_anh00010000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: array of cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_objects<>nil) and (sema_objects.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_17(command_queue, num_sema_objects, sema_objects[0], sema_payload_list, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_17_anh00010000(command_queue, num_sema_objects, IntPtr.Zero, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_0_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_1_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_4_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_5_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_0_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_1_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_0(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_1(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_4(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_5(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_12_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_13_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_12(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_13(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_16(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; var sema_objects: cl_semaphore; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_17(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_36(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_36_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_36_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_36_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_36_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_36_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_36_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_37(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_37_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_37_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_37_anh00001010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_37_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueSignalSemaphoresKHR_ovr_37_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueSignalSemaphoresKHR_ovr_37_anh00001010(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_38_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_36_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_39_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_37_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_40(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_40_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_40(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_40_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_41(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_41_anh00001000(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: array of UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (sema_payload_list<>nil) and (sema_payload_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_41(command_queue, num_sema_objects, sema_objects, sema_payload_list[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_41_anh00001000(command_queue, num_sema_objects, sema_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_36_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_37_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_36(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_37(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_40(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; var sema_payload_list: UInt64; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_41(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_48(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_48_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_48(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_48_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_49(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    private static function z_EnqueueSignalSemaphoresKHR_ovr_49_anh00000010(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueSignalSemaphoresKHR_ovr_49(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueSignalSemaphoresKHR_ovr_49_anh00000010(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_48(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_49(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_52(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_52(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueSignalSemaphoresKHR_ovr_53(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueSignalSemaphoresKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueSignalSemaphoresKHR(command_queue: cl_command_queue; num_sema_objects: UInt32; sema_objects: IntPtr; sema_payload_list: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueSignalSemaphoresKHR_ovr_53(command_queue, num_sema_objects, sema_objects, sema_payload_list, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_GetSemaphoreInfoKHR_ovr_0(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreInfoKHR';
    private static function z_GetSemaphoreInfoKHR_ovr_0_anh000001(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreInfoKHR(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetSemaphoreInfoKHR_ovr_0(sema_object, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetSemaphoreInfoKHR_ovr_0_anh000001(sema_object, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreInfoKHR(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetSemaphoreInfoKHR_ovr_0(sema_object, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetSemaphoreInfoKHR_ovr_2(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreInfoKHR(sema_object: cl_semaphore; param_name: SemaphoreInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetSemaphoreInfoKHR_ovr_2(sema_object, param_name, param_value_size, param_value, param_value_size_ret);
    
    private static function z_ReleaseSemaphoreKHR_ovr_0(sema_object: cl_semaphore): ErrorCode;
    external 'opencl' name 'clReleaseSemaphoreKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseSemaphoreKHR(sema_object: cl_semaphore): ErrorCode :=
    z_ReleaseSemaphoreKHR_ovr_0(sema_object);
    
    private static function z_RetainSemaphoreKHR_ovr_0(sema_object: cl_semaphore): ErrorCode;
    external 'opencl' name 'clRetainSemaphoreKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainSemaphoreKHR(sema_object: cl_semaphore): ErrorCode :=
    z_RetainSemaphoreKHR_ovr_0(sema_object);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clExternalSemaphoreKHR = static class
    public const _ExtStr = 'khr_external_semaphore';
    
    private static function z_GetSemaphoreHandleForTypeKHR_ovr_0(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; var handle_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreHandleForTypeKHR';
    private static function z_GetSemaphoreHandleForTypeKHR_ovr_0_anh0000001(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; handle_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreHandleForTypeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreHandleForTypeKHR(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; handle_size_ret: array of UIntPtr): ErrorCode :=
    if (handle_size_ret<>nil) and (handle_size_ret.Length<>0) then
      z_GetSemaphoreHandleForTypeKHR_ovr_0(sema_object, device, handle_type, handle_size, handle_ptr, handle_size_ret[0]) else
      z_GetSemaphoreHandleForTypeKHR_ovr_0_anh0000001(sema_object, device, handle_type, handle_size, handle_ptr, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreHandleForTypeKHR(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; var handle_size_ret: UIntPtr): ErrorCode :=
    z_GetSemaphoreHandleForTypeKHR_ovr_0(sema_object, device, handle_type, handle_size, handle_ptr, handle_size_ret);
    private static function z_GetSemaphoreHandleForTypeKHR_ovr_2(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; handle_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSemaphoreHandleForTypeKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSemaphoreHandleForTypeKHR(sema_object: cl_semaphore; device: cl_device_id; handle_type: ExternalSemaphoreHandleTypeKhr; handle_size: UIntPtr; handle_ptr: IntPtr; handle_size_ret: IntPtr): ErrorCode :=
    z_GetSemaphoreHandleForTypeKHR_ovr_2(sema_object, device, handle_type, handle_size, handle_ptr, handle_size_ret);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clExternalMemoryKHR = static class
    public const _ExtStr = 'khr_external_memory';
    
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_0(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0000010(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0001010(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_1(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0000010(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0001010(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_4(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_4(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_4_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_5(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_5(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_5_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_0_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_1_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_4(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_5(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_12(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_12(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_12_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_13(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_13(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueAcquireExternalMemObjectsKHR_ovr_13_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_12(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_13(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_16(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_16(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueAcquireExternalMemObjectsKHR_ovr_17(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueAcquireExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueAcquireExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueAcquireExternalMemObjectsKHR_ovr_17(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_0(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0001010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0000010(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0001010(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_1(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0001010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0000010(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0001010(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_2_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_3_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_4(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_4_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_4(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_4_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_5(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_5_anh0001000(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: array of cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (mem_objects<>nil) and (mem_objects.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_5(command_queue, num_mem_objects, mem_objects[0], num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_5_anh0001000(command_queue, num_mem_objects, IntPtr.Zero, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_0_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_1_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_0(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_1(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_4(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; var mem_objects: cl_mem; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_5(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_12(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_12_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_12(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_12_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_13(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_13_anh0000010(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_13(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueReleaseExternalMemObjectsKHR_ovr_13_anh0000010(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_12(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_13(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_16(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_16(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueReleaseExternalMemObjectsKHR_ovr_17(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueReleaseExternalMemObjectsKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueReleaseExternalMemObjectsKHR(command_queue: cl_command_queue; num_mem_objects: UInt32; mem_objects: IntPtr; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueReleaseExternalMemObjectsKHR_ovr_17(command_queue, num_mem_objects, mem_objects, num_events_in_wait_list, event_wait_list, &event);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharingFormatQueryGlINTEL = static class
    public const _ExtStr = 'intel_sharing_format_query_gl';
    
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000011(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: array of UInt32; num_texture_formats: array of UInt32): ErrorCode :=
    if (gl_formats<>nil) and (gl_formats.Length<>0) then
      if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
        z_GetSupportedGLTextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, gl_formats[0], num_texture_formats[0]) else
        z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000001(context, flags, image_type, num_entries, gl_formats[0], IntPtr.Zero) else
      if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
        z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_texture_formats[0]) else
        z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000011(context, flags, image_type, num_entries, IntPtr.Zero, IntPtr.Zero);
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_1_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: array of UInt32; var num_texture_formats: UInt32): ErrorCode :=
    if (gl_formats<>nil) and (gl_formats.Length<>0) then
      z_GetSupportedGLTextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, gl_formats[0], num_texture_formats) else
      z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_texture_formats);
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_2_anh0000010(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: array of UInt32; num_texture_formats: IntPtr): ErrorCode :=
    if (gl_formats<>nil) and (gl_formats.Length<>0) then
      z_GetSupportedGLTextureFormatsINTEL_ovr_2(context, flags, image_type, num_entries, gl_formats[0], num_texture_formats) else
      z_GetSupportedGLTextureFormatsINTEL_ovr_2_anh0000010(context, flags, image_type, num_entries, IntPtr.Zero, num_texture_formats);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; num_texture_formats: array of UInt32): ErrorCode :=
    if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
      z_GetSupportedGLTextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, gl_formats, num_texture_formats[0]) else
      z_GetSupportedGLTextureFormatsINTEL_ovr_0_anh0000001(context, flags, image_type, num_entries, gl_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; var num_texture_formats: UInt32): ErrorCode :=
    z_GetSupportedGLTextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, gl_formats, num_texture_formats);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; var gl_formats: UInt32; num_texture_formats: IntPtr): ErrorCode :=
    z_GetSupportedGLTextureFormatsINTEL_ovr_2(context, flags, image_type, num_entries, gl_formats, num_texture_formats);
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_6(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_6_anh0000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: array of UInt32): ErrorCode :=
    if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
      z_GetSupportedGLTextureFormatsINTEL_ovr_6(context, flags, image_type, num_entries, gl_formats, num_texture_formats[0]) else
      z_GetSupportedGLTextureFormatsINTEL_ovr_6_anh0000001(context, flags, image_type, num_entries, gl_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode :=
    z_GetSupportedGLTextureFormatsINTEL_ovr_6(context, flags, image_type, num_entries, gl_formats, num_texture_formats);
    private static function z_GetSupportedGLTextureFormatsINTEL_ovr_8(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedGLTextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedGLTextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; gl_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode :=
    z_GetSupportedGLTextureFormatsINTEL_ovr_8(context, flags, image_type, num_entries, gl_formats, num_texture_formats);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharingFormatQueryDx9INTEL = static class
    public const _ExtStr = 'intel_sharing_format_query_dx9';
    
    private static function z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; var num_surface_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedDX9MediaSurfaceFormatsINTEL';
    private static function z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_0_anh00000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedDX9MediaSurfaceFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedDX9MediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; num_surface_formats: array of UInt32): ErrorCode :=
    if (num_surface_formats<>nil) and (num_surface_formats.Length<>0) then
      z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, dx9_formats, num_surface_formats[0]) else
      z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_0_anh00000001(context, flags, image_type, plane, num_entries, dx9_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedDX9MediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; var num_surface_formats: UInt32): ErrorCode :=
    z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, dx9_formats, num_surface_formats);
    private static function z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedDX9MediaSurfaceFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedDX9MediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; dx9_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode :=
    z_GetSupportedDX9MediaSurfaceFormatsINTEL_ovr_2(context, flags, image_type, plane, num_entries, dx9_formats, num_surface_formats);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharingFormatQueryD3d10INTEL = static class
    public const _ExtStr = 'intel_sharing_format_query_d3d10';
    
    private static function z_GetSupportedD3D10TextureFormatsINTEL_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D10TextureFormatsINTEL';
    private static function z_GetSupportedD3D10TextureFormatsINTEL_ovr_0_anh0000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D10TextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D10TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; num_texture_formats: array of UInt32): ErrorCode :=
    if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
      z_GetSupportedD3D10TextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, d3d10_formats, num_texture_formats[0]) else
      z_GetSupportedD3D10TextureFormatsINTEL_ovr_0_anh0000001(context, flags, image_type, num_entries, d3d10_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D10TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode :=
    z_GetSupportedD3D10TextureFormatsINTEL_ovr_0(context, flags, image_type, num_entries, d3d10_formats, num_texture_formats);
    private static function z_GetSupportedD3D10TextureFormatsINTEL_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D10TextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D10TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; num_entries: UInt32; d3d10_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode :=
    z_GetSupportedD3D10TextureFormatsINTEL_ovr_2(context, flags, image_type, num_entries, d3d10_formats, num_texture_formats);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharingFormatQueryD3d11INTEL = static class
    public const _ExtStr = 'intel_sharing_format_query_d3d11';
    
    private static function z_GetSupportedD3D11TextureFormatsINTEL_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D11TextureFormatsINTEL';
    private static function z_GetSupportedD3D11TextureFormatsINTEL_ovr_0_anh00000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D11TextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D11TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; num_texture_formats: array of UInt32): ErrorCode :=
    if (num_texture_formats<>nil) and (num_texture_formats.Length<>0) then
      z_GetSupportedD3D11TextureFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, d3d11_formats, num_texture_formats[0]) else
      z_GetSupportedD3D11TextureFormatsINTEL_ovr_0_anh00000001(context, flags, image_type, plane, num_entries, d3d11_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D11TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; var num_texture_formats: UInt32): ErrorCode :=
    z_GetSupportedD3D11TextureFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, d3d11_formats, num_texture_formats);
    private static function z_GetSupportedD3D11TextureFormatsINTEL_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedD3D11TextureFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedD3D11TextureFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; d3d11_formats: IntPtr; num_texture_formats: IntPtr): ErrorCode :=
    z_GetSupportedD3D11TextureFormatsINTEL_ovr_2(context, flags, image_type, plane, num_entries, d3d11_formats, num_texture_formats);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clSharingFormatQueryVaApiINTEL = static class
    public const _ExtStr = 'intel_sharing_format_query_va_api';
    
    private static function z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_0(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; var num_surface_formats: UInt32): ErrorCode;
    external 'opencl' name 'clGetSupportedVA_APIMediaSurfaceFormatsINTEL';
    private static function z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_0_anh00000001(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedVA_APIMediaSurfaceFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedVA_APIMediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; num_surface_formats: array of UInt32): ErrorCode :=
    if (num_surface_formats<>nil) and (num_surface_formats.Length<>0) then
      z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, va_api_formats, num_surface_formats[0]) else
      z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_0_anh00000001(context, flags, image_type, plane, num_entries, va_api_formats, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedVA_APIMediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; var num_surface_formats: UInt32): ErrorCode :=
    z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_0(context, flags, image_type, plane, num_entries, va_api_formats, num_surface_formats);
    private static function z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_2(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode;
    external 'opencl' name 'clGetSupportedVA_APIMediaSurfaceFormatsINTEL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSupportedVA_APIMediaSurfaceFormatsINTEL(context: cl_context; flags: MemFlags; image_type: MemObjectType; plane: UInt32; num_entries: UInt32; va_api_formats: IntPtr; num_surface_formats: IntPtr): ErrorCode :=
    z_GetSupportedVA_APIMediaSurfaceFormatsINTEL_ovr_2(context, flags, image_type, plane, num_entries, va_api_formats, num_surface_formats);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clContentSizePOCL = static class
    public const _ExtStr = 'pocl_content_size';
    
    private static function z_SetContentSizeBufferPoCL_ovr_0(buffer: cl_mem; content_size_buffer: cl_mem): ErrorCode;
    external 'opencl' name 'clSetContentSizeBufferPoCL';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetContentSizeBufferPoCL(buffer: cl_mem; content_size_buffer: cl_mem): ErrorCode :=
    z_SetContentSizeBufferPoCL_ovr_0(buffer, content_size_buffer);
    
  end;
  
  [PCUNotRestore]
  [System.Security.SuppressUnmanagedCodeSecurity]
  clCommandBufferKHR = static class
    public const _ExtStr = 'khr_command_buffer';
    
    private static function z_CreateCommandBufferKHR_ovr_0(num_queues: UInt32; var queues: cl_command_queue; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    private static function z_CreateCommandBufferKHR_ovr_0_anh00100(num_queues: UInt32; queues: IntPtr; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    private static function z_CreateCommandBufferKHR_ovr_0_anh00010(num_queues: UInt32; var queues: cl_command_queue; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    private static function z_CreateCommandBufferKHR_ovr_0_anh00110(num_queues: UInt32; queues: IntPtr; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; properties: array of CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    if (queues<>nil) and (queues.Length<>0) then
      if (properties<>nil) and (properties.Length<>0) then
        z_CreateCommandBufferKHR_ovr_0(num_queues, queues[0], properties[0], errcode_ret) else
        z_CreateCommandBufferKHR_ovr_0_anh00010(num_queues, queues[0], IntPtr.Zero, errcode_ret) else
      if (properties<>nil) and (properties.Length<>0) then
        z_CreateCommandBufferKHR_ovr_0_anh00100(num_queues, IntPtr.Zero, properties[0], errcode_ret) else
        z_CreateCommandBufferKHR_ovr_0_anh00110(num_queues, IntPtr.Zero, IntPtr.Zero, errcode_ret);
    private static function z_CreateCommandBufferKHR_ovr_1_anh00100(num_queues: UInt32; queues: IntPtr; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    if (queues<>nil) and (queues.Length<>0) then
      z_CreateCommandBufferKHR_ovr_0(num_queues, queues[0], properties, errcode_ret) else
      z_CreateCommandBufferKHR_ovr_0_anh00100(num_queues, IntPtr.Zero, properties, errcode_ret);
    private static function z_CreateCommandBufferKHR_ovr_2(num_queues: UInt32; var queues: cl_command_queue; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    private static function z_CreateCommandBufferKHR_ovr_2_anh00100(num_queues: UInt32; queues: IntPtr; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer :=
    if (queues<>nil) and (queues.Length<>0) then
      z_CreateCommandBufferKHR_ovr_2(num_queues, queues[0], properties, errcode_ret) else
      z_CreateCommandBufferKHR_ovr_2_anh00100(num_queues, IntPtr.Zero, properties, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; properties: array of CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateCommandBufferKHR_ovr_0(num_queues, queues, properties[0], errcode_ret) else
      z_CreateCommandBufferKHR_ovr_0_anh00010(num_queues, queues, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    z_CreateCommandBufferKHR_ovr_0(num_queues, queues, properties, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer :=
    z_CreateCommandBufferKHR_ovr_2(num_queues, queues, properties, errcode_ret);
    private static function z_CreateCommandBufferKHR_ovr_6(num_queues: UInt32; queues: IntPtr; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    private static function z_CreateCommandBufferKHR_ovr_6_anh00010(num_queues: UInt32; queues: IntPtr; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: IntPtr; properties: array of CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    if (properties<>nil) and (properties.Length<>0) then
      z_CreateCommandBufferKHR_ovr_6(num_queues, queues, properties[0], errcode_ret) else
      z_CreateCommandBufferKHR_ovr_6_anh00010(num_queues, queues, IntPtr.Zero, errcode_ret);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: IntPtr; var properties: CommandBufferPropertiesKhr; var errcode_ret: ErrorCode): cl_command_buffer :=
    z_CreateCommandBufferKHR_ovr_6(num_queues, queues, properties, errcode_ret);
    private static function z_CreateCommandBufferKHR_ovr_8(num_queues: UInt32; queues: IntPtr; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer;
    external 'opencl' name 'clCreateCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateCommandBufferKHR(num_queues: UInt32; queues: IntPtr; properties: IntPtr; var errcode_ret: ErrorCode): cl_command_buffer :=
    z_CreateCommandBufferKHR_ovr_8(num_queues, queues, properties, errcode_ret);
    
    private static function z_FinalizeCommandBufferKHR_ovr_0(command_buffer: cl_command_buffer): ErrorCode;
    external 'opencl' name 'clFinalizeCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function FinalizeCommandBufferKHR(command_buffer: cl_command_buffer): ErrorCode :=
    z_FinalizeCommandBufferKHR_ovr_0(command_buffer);
    
    private static function z_RetainCommandBufferKHR_ovr_0(command_buffer: cl_command_buffer): ErrorCode;
    external 'opencl' name 'clRetainCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RetainCommandBufferKHR(command_buffer: cl_command_buffer): ErrorCode :=
    z_RetainCommandBufferKHR_ovr_0(command_buffer);
    
    private static function z_ReleaseCommandBufferKHR_ovr_0(command_buffer: cl_command_buffer): ErrorCode;
    external 'opencl' name 'clReleaseCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseCommandBufferKHR(command_buffer: cl_command_buffer): ErrorCode :=
    z_ReleaseCommandBufferKHR_ovr_0(command_buffer);
    
    private static function z_EnqueueCommandBufferKHR_ovr_0(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_0_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_0_anh0000010(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_0_anh0010010(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueCommandBufferKHR_ovr_0(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueCommandBufferKHR_ovr_0_anh0000010(num_queues, queues[0], command_buffer, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueCommandBufferKHR_ovr_0_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueCommandBufferKHR_ovr_0_anh0010010(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_1(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_1_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_1_anh0000010(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_1_anh0010010(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueCommandBufferKHR_ovr_1(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueCommandBufferKHR_ovr_1_anh0000010(num_queues, queues[0], command_buffer, num_events_in_wait_list, IntPtr.Zero, &event) else
      if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
        z_EnqueueCommandBufferKHR_ovr_1_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
        z_EnqueueCommandBufferKHR_ovr_1_anh0010010(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_2_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_0(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueCommandBufferKHR_ovr_0_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_3_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_1(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueCommandBufferKHR_ovr_1_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_4(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_4_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_4(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueCommandBufferKHR_ovr_4_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_5(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_5_anh0010000(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: array of cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    if (queues<>nil) and (queues.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_5(num_queues, queues[0], command_buffer, num_events_in_wait_list, event_wait_list, &event) else
      z_EnqueueCommandBufferKHR_ovr_5_anh0010000(num_queues, IntPtr.Zero, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_0(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCommandBufferKHR_ovr_0_anh0000010(num_queues, queues, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_1(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCommandBufferKHR_ovr_1_anh0000010(num_queues, queues, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_0(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_1(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_4(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; var queues: cl_command_queue; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_5(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_12(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_12_anh0000010(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; var &event: cl_event): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_12(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCommandBufferKHR_ovr_12_anh0000010(num_queues, queues, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_13(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    private static function z_EnqueueCommandBufferKHR_ovr_13_anh0000010(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: array of cl_event; &event: IntPtr): ErrorCode :=
    if (event_wait_list<>nil) and (event_wait_list.Length<>0) then
      z_EnqueueCommandBufferKHR_ovr_13(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list[0], &event) else
      z_EnqueueCommandBufferKHR_ovr_13_anh0000010(num_queues, queues, command_buffer, num_events_in_wait_list, IntPtr.Zero, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; var &event: cl_event): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_12(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; var event_wait_list: cl_event; &event: IntPtr): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_13(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_16(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; var &event: cl_event): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_16(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    private static function z_EnqueueCommandBufferKHR_ovr_17(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode;
    external 'opencl' name 'clEnqueueCommandBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnqueueCommandBufferKHR(num_queues: UInt32; queues: IntPtr; command_buffer: cl_command_buffer; num_events_in_wait_list: UInt32; event_wait_list: IntPtr; &event: IntPtr): ErrorCode :=
    z_EnqueueCommandBufferKHR_ovr_17(num_queues, queues, command_buffer, num_events_in_wait_list, event_wait_list, &event);
    
    private static function z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_0_anh0000111(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle[0]) else
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle[0]) else
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000011(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, IntPtr.Zero) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle[0]) else
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000101(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000110(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle[0]) else
          z_CommandBarrierWithWaitListKHR_ovr_0_anh0000111(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandBarrierWithWaitListKHR_ovr_1_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_1_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_1_anh0000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000110(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_2(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_2_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_2_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_2_anh0000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_2(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandBarrierWithWaitListKHR_ovr_2_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_2_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandBarrierWithWaitListKHR_ovr_2_anh0000110(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_3_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_3_anh0000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000101(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandBarrierWithWaitListKHR_ovr_4_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_0_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_5_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_2(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_2_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_6_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_6_anh0000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_6_anh0000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_6(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_6_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_6_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_6_anh0000101(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandBarrierWithWaitListKHR_ovr_7_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_6(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_6_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_8(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_8_anh0000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_8(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_8_anh0000100(command_buffer, command_queue, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_0_anh0000011(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_0_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_2(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_2_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandBarrierWithWaitListKHR_ovr_0_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_0(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_2(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_6(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandBarrierWithWaitListKHR_ovr_6_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_6(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_8(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_18(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_18_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_18_anh0000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_18_anh0000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_18(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_18_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandBarrierWithWaitListKHR_ovr_18_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandBarrierWithWaitListKHR_ovr_18_anh0000011(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandBarrierWithWaitListKHR_ovr_19_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_18(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_18_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_20(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_20_anh0000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_20(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandBarrierWithWaitListKHR_ovr_20_anh0000010(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_18(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandBarrierWithWaitListKHR_ovr_18_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_18(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_20(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_24(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    private static function z_CommandBarrierWithWaitListKHR_ovr_24_anh0000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandBarrierWithWaitListKHR_ovr_24(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandBarrierWithWaitListKHR_ovr_24_anh0000001(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_24(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandBarrierWithWaitListKHR_ovr_26(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandBarrierWithWaitListKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandBarrierWithWaitListKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandBarrierWithWaitListKHR_ovr_26(command_buffer, command_queue, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandCopyBufferKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_0_anh000000000111(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle[0]) else
          z_CommandCopyBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandCopyBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle[0]) else
          z_CommandCopyBufferKHR_ovr_0_anh000000000011(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, IntPtr.Zero) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandCopyBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle[0]) else
          z_CommandCopyBufferKHR_ovr_0_anh000000000101(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandCopyBufferKHR_ovr_0_anh000000000110(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle[0]) else
          z_CommandCopyBufferKHR_ovr_0_anh000000000111(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandCopyBufferKHR_ovr_1_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_1_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_1_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000110(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_2(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_2_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_2_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_2_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandCopyBufferKHR_ovr_2(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandCopyBufferKHR_ovr_2_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandCopyBufferKHR_ovr_2_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandCopyBufferKHR_ovr_2_anh000000000110(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_3_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_3_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000101(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandCopyBufferKHR_ovr_4_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_5_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferKHR_ovr_2(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferKHR_ovr_2_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_6_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_6_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_6_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_6_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_6_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_6_anh000000000101(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandCopyBufferKHR_ovr_7_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferKHR_ovr_6_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_8(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_8_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferKHR_ovr_8(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferKHR_ovr_8_anh000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_0_anh000000000011(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandCopyBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandCopyBufferKHR_ovr_2(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandCopyBufferKHR_ovr_2_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandCopyBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_2(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandCopyBufferKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandCopyBufferKHR_ovr_6_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_8(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_18(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_18_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_18_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_18_anh000000000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_18(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_18_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandCopyBufferKHR_ovr_18_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandCopyBufferKHR_ovr_18_anh000000000011(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandCopyBufferKHR_ovr_19_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandCopyBufferKHR_ovr_18(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandCopyBufferKHR_ovr_18_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_20(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_20_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandCopyBufferKHR_ovr_20(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandCopyBufferKHR_ovr_20_anh000000000010(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandCopyBufferKHR_ovr_18(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandCopyBufferKHR_ovr_18_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_18(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_20(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_24(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    private static function z_CommandCopyBufferKHR_ovr_24_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandCopyBufferKHR_ovr_24(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandCopyBufferKHR_ovr_24_anh000000000001(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_24(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferKHR_ovr_26(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_offset: UIntPtr; dst_offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferKHR_ovr_26(command_buffer, command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandCopyBufferRectKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    private static function z_CommandCopyBufferRectKHR_ovr_0_anh0000000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferRectKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferRectKHR_ovr_0_anh0000000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    private static function z_CommandCopyBufferRectKHR_ovr_1_anh0000000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferRectKHR_ovr_1(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferRectKHR_ovr_1_anh0000000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_1(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_4(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_5(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    private static function z_CommandCopyBufferRectKHR_ovr_6_anh0000000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferRectKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferRectKHR_ovr_6_anh0000000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_7(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    private static function z_CommandCopyBufferRectKHR_ovr_7_anh0000000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferRectKHR_ovr_7(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferRectKHR_ovr_7_anh0000000000000100(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_7(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_10(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_10(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferRectKHR_ovr_11(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferRectKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferRectKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; src_row_pitch: UIntPtr; src_slice_pitch: UIntPtr; dst_row_pitch: UIntPtr; dst_slice_pitch: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferRectKHR_ovr_11(command_buffer, command_queue, src_buffer, dst_buffer, src_origin, dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandCopyBufferToImageKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    private static function z_CommandCopyBufferToImageKHR_ovr_0_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferToImageKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferToImageKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    private static function z_CommandCopyBufferToImageKHR_ovr_1_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferToImageKHR_ovr_1(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferToImageKHR_ovr_1_anh000000000100(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_0(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_1(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_4(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_5(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    private static function z_CommandCopyBufferToImageKHR_ovr_6_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferToImageKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferToImageKHR_ovr_6_anh000000000100(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_7(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    private static function z_CommandCopyBufferToImageKHR_ovr_7_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyBufferToImageKHR_ovr_7(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyBufferToImageKHR_ovr_7_anh000000000100(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_6(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_7(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_10(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_10(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyBufferToImageKHR_ovr_11(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyBufferToImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyBufferToImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_buffer: cl_mem; dst_image: cl_mem; src_offset: UIntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyBufferToImageKHR_ovr_11(command_buffer, command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandCopyImageKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    private static function z_CommandCopyImageKHR_ovr_0_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageKHR_ovr_0(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    private static function z_CommandCopyImageKHR_ovr_1_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageKHR_ovr_1(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageKHR_ovr_1_anh000000000100(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageKHR_ovr_0(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageKHR_ovr_1(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageKHR_ovr_4(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; var src_origin: UIntPtr; var dst_origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageKHR_ovr_5(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    private static function z_CommandCopyImageKHR_ovr_6_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageKHR_ovr_6(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageKHR_ovr_6_anh000000000100(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_7(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    private static function z_CommandCopyImageKHR_ovr_7_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageKHR_ovr_7(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageKHR_ovr_7_anh000000000100(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageKHR_ovr_6(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageKHR_ovr_7(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_10(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageKHR_ovr_10(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageKHR_ovr_11(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_image: cl_mem; src_origin: IntPtr; dst_origin: IntPtr; region: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageKHR_ovr_11(command_buffer, command_queue, src_image, dst_image, src_origin, dst_origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandCopyImageToBufferKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    private static function z_CommandCopyImageToBufferKHR_ovr_0_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageToBufferKHR_ovr_0(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageToBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    private static function z_CommandCopyImageToBufferKHR_ovr_1_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageToBufferKHR_ovr_1(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageToBufferKHR_ovr_1_anh000000000100(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_0(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_1(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_4(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; var src_origin: UIntPtr; var region: UIntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_5(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    private static function z_CommandCopyImageToBufferKHR_ovr_6_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageToBufferKHR_ovr_6(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageToBufferKHR_ovr_6_anh000000000100(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_7(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    private static function z_CommandCopyImageToBufferKHR_ovr_7_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandCopyImageToBufferKHR_ovr_7(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandCopyImageToBufferKHR_ovr_7_anh000000000100(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_6(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_7(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_10(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_10(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandCopyImageToBufferKHR_ovr_11(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandCopyImageToBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandCopyImageToBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; src_image: cl_mem; dst_buffer: cl_mem; src_origin: IntPtr; region: IntPtr; dst_offset: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandCopyImageToBufferKHR_ovr_11(command_buffer, command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandFillBufferKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_0_anh000000000111(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle[0]) else
          z_CommandFillBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandFillBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle[0]) else
          z_CommandFillBufferKHR_ovr_0_anh000000000011(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, IntPtr.Zero) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandFillBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle[0]) else
          z_CommandFillBufferKHR_ovr_0_anh000000000101(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], IntPtr.Zero) else
        if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
          z_CommandFillBufferKHR_ovr_0_anh000000000110(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle[0]) else
          z_CommandFillBufferKHR_ovr_0_anh000000000111(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandFillBufferKHR_ovr_1_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_1_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_1_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandFillBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandFillBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandFillBufferKHR_ovr_0_anh000000000110(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_2(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_2_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_2_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_2_anh000000000110(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandFillBufferKHR_ovr_2(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point[0], mutable_handle) else
        z_CommandFillBufferKHR_ovr_2_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], IntPtr.Zero, mutable_handle) else
      if (sync_point<>nil) and (sync_point.Length<>0) then
        z_CommandFillBufferKHR_ovr_2_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point[0], mutable_handle) else
        z_CommandFillBufferKHR_ovr_2_anh000000000110(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, IntPtr.Zero, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_3_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_3_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_0_anh000000000101(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandFillBufferKHR_ovr_4_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandFillBufferKHR_ovr_0_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_5_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandFillBufferKHR_ovr_2(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandFillBufferKHR_ovr_2_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_6_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_6_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_6_anh000000000101(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_6(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_6_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_6_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_6_anh000000000101(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, IntPtr.Zero);
    private static function z_CommandFillBufferKHR_ovr_7_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandFillBufferKHR_ovr_6(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandFillBufferKHR_ovr_6_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_8(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_8_anh000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandFillBufferKHR_ovr_8(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandFillBufferKHR_ovr_8_anh000000000100(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_0_anh000000000011(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandFillBufferKHR_ovr_0_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandFillBufferKHR_ovr_2(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandFillBufferKHR_ovr_2_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandFillBufferKHR_ovr_0_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandFillBufferKHR_ovr_0(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandFillBufferKHR_ovr_2(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandFillBufferKHR_ovr_6(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandFillBufferKHR_ovr_6_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandFillBufferKHR_ovr_6(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandFillBufferKHR_ovr_8(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_18(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_18_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_18_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_18_anh000000000011(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_18(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_18_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], IntPtr.Zero) else
      if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
        z_CommandFillBufferKHR_ovr_18_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle[0]) else
        z_CommandFillBufferKHR_ovr_18_anh000000000011(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, IntPtr.Zero);
    private static function z_CommandFillBufferKHR_ovr_19_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandFillBufferKHR_ovr_18(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandFillBufferKHR_ovr_18_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_20(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_20_anh000000000010(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: array of UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point<>nil) and (sync_point.Length<>0) then
      z_CommandFillBufferKHR_ovr_20(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point[0], mutable_handle) else
      z_CommandFillBufferKHR_ovr_20_anh000000000010(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, IntPtr.Zero, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandFillBufferKHR_ovr_18(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandFillBufferKHR_ovr_18_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandFillBufferKHR_ovr_18(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandFillBufferKHR_ovr_20(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_24(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    private static function z_CommandFillBufferKHR_ovr_24_anh000000000001(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: array of cl_mutable_command): ErrorCode :=
    if (mutable_handle<>nil) and (mutable_handle.Length<>0) then
      z_CommandFillBufferKHR_ovr_24(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle[0]) else
      z_CommandFillBufferKHR_ovr_24_anh000000000001(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandFillBufferKHR_ovr_24(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandFillBufferKHR_ovr_26(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillBufferKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillBufferKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; buffer: cl_mem; pattern: IntPtr; pattern_size: UIntPtr; offset: UIntPtr; size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; sync_point: IntPtr; mutable_handle: IntPtr): ErrorCode :=
    z_CommandFillBufferKHR_ovr_26(command_buffer, command_queue, buffer, pattern, pattern_size, offset, size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_CommandFillImageKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    private static function z_CommandFillImageKHR_ovr_0_anh00000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode; where T: record;
    begin
      if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
        Result := z_CommandFillImageKHR_ovr_0(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
        Result := z_CommandFillImageKHR_ovr_0_anh00000000100(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    end;
    private static function z_CommandFillImageKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    private static function z_CommandFillImageKHR_ovr_1_anh00000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode; where T: record;
    begin
      if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
        Result := z_CommandFillImageKHR_ovr_1(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
        Result := z_CommandFillImageKHR_ovr_1_anh00000000100(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode; where T: record;
    begin
      Result := z_CommandFillImageKHR_ovr_0(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    end;
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_CommandFillImageKHR_ovr_1(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    end;
    private static function z_CommandFillImageKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode; where T: record;
    begin
      Result := z_CommandFillImageKHR_ovr_4(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    end;
    private static function z_CommandFillImageKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: Byte; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandFillImageKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandFillImageKHR<T>(command_buffer: cl_command_buffer; command_queue: cl_command_queue; image: cl_mem; var fill_color: T; var origin: UIntPtr; var region: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode; where T: record;
    begin
      Result := z_CommandFillImageKHR_ovr_5(command_buffer, command_queue, image, PByte(pointer(@fill_color))^, origin, region, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    end;
    
    private static function z_CommandNDRangeKernelKHR_ovr_0(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    private static function z_CommandNDRangeKernelKHR_ovr_0_anh0000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandNDRangeKernelKHR_ovr_0(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandNDRangeKernelKHR_ovr_0_anh0000000000100(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_1(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    private static function z_CommandNDRangeKernelKHR_ovr_1_anh0000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandNDRangeKernelKHR_ovr_1(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandNDRangeKernelKHR_ovr_1_anh0000000000100(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_0(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_1(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_4(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_4(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_5(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; var properties: UInt64; kernel: cl_kernel; work_dim: UInt32; var global_work_offset: UIntPtr; var global_work_size: UIntPtr; var local_work_size: UIntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_5(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_6(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    private static function z_CommandNDRangeKernelKHR_ovr_6_anh0000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandNDRangeKernelKHR_ovr_6(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandNDRangeKernelKHR_ovr_6_anh0000000000100(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_7(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    private static function z_CommandNDRangeKernelKHR_ovr_7_anh0000000000100(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: array of UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    if (sync_point_wait_list<>nil) and (sync_point_wait_list.Length<>0) then
      z_CommandNDRangeKernelKHR_ovr_7(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list[0], sync_point, mutable_handle) else
      z_CommandNDRangeKernelKHR_ovr_7_anh0000000000100(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, IntPtr.Zero, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_6(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; var sync_point_wait_list: UInt32; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_7(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_10(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; var mutable_handle: cl_mutable_command): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_10(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    private static function z_CommandNDRangeKernelKHR_ovr_11(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode;
    external 'opencl' name 'clCommandNDRangeKernelKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CommandNDRangeKernelKHR(command_buffer: cl_command_buffer; command_queue: cl_command_queue; properties: IntPtr; kernel: cl_kernel; work_dim: UInt32; global_work_offset: IntPtr; global_work_size: IntPtr; local_work_size: IntPtr; num_sync_points_in_wait_list: UInt32; sync_point_wait_list: IntPtr; var sync_point: UInt32; mutable_handle: IntPtr): ErrorCode :=
    z_CommandNDRangeKernelKHR_ovr_11(command_buffer, command_queue, properties, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_sync_points_in_wait_list, sync_point_wait_list, sync_point, mutable_handle);
    
    private static function z_GetCommandBufferInfoKHR_ovr_0(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandBufferInfoKHR';
    private static function z_GetCommandBufferInfoKHR_ovr_0_anh000001(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandBufferInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandBufferInfoKHR(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: array of UIntPtr): ErrorCode :=
    if (param_value_size_ret<>nil) and (param_value_size_ret.Length<>0) then
      z_GetCommandBufferInfoKHR_ovr_0(command_buffer, param_name, param_value_size, param_value, param_value_size_ret[0]) else
      z_GetCommandBufferInfoKHR_ovr_0_anh000001(command_buffer, param_name, param_value_size, param_value, IntPtr.Zero);
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandBufferInfoKHR(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; var param_value_size_ret: UIntPtr): ErrorCode :=
    z_GetCommandBufferInfoKHR_ovr_0(command_buffer, param_name, param_value_size, param_value, param_value_size_ret);
    private static function z_GetCommandBufferInfoKHR_ovr_2(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode;
    external 'opencl' name 'clGetCommandBufferInfoKHR';
    public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCommandBufferInfoKHR(command_buffer: cl_command_buffer; param_name: CommandBufferInfoKhr; param_value_size: UIntPtr; param_value: IntPtr; param_value_size_ret: IntPtr): ErrorCode :=
    z_GetCommandBufferInfoKHR_ovr_2(command_buffer, param_name, param_value_size, param_value, param_value_size_ret);
    
  end;
  
  {$endregion Extensions}
  
  {$endregion Функции}
  
implementation

{$region Misc}

procedure ErrorCode.RaiseIfError :=
if IS_ERROR then raise new OpenCLException(self);

{$endregion Misc}

end.